react-native-nitro-ar 2026.2.1 → 2026.2.2

package/lib/typescript/src/specs/ARObjectMeasurement.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ARObjectMeasurement.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/ARObjectMeasurement.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,gDAAgD;AAChD,MAAM,WAAW,mBAAmB;IAClC,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gDAAgD;IAChD,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,2BAA2B;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,oCAAoC;AACpC,MAAM,WAAW,oBAAqB,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,CAAC;IAC1E,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAC/B,mCAAmC;IACnC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,iEAAiE;IACjE,cAAc,IAAI,MAAM,EAAE,CAAC;IAC3B,mCAAmC;IACnC,OAAO,IAAI,mBAAmB,GAAG,SAAS,CAAC;CAC5C"}

package/lib/typescript/src/specs/ARView.nitro.d.ts

@@ -1,4 +1,5 @@
 import type { HybridView, HybridViewMethods, HybridViewProps } from "react-native-nitro-modules";
+import type { ARObjectMeasurement, ARSegmentationResult } from "./ARObjectMeasurement.nitro";
 import type { SceneReconstructionMode } from "./ARSceneMesh.nitro";
 export interface ARViewHitResult {
     x: number;
@@ -44,6 +45,10 @@ export interface ARViewMethods extends HybridViewMethods {
     resetSession(): void;
     /** Check if LiDAR is available on this device */
     isLiDARAvailable(): boolean;
+    /** Segment an object at the given screen point (normalized 0-1) */
+    segmentObject(x: number, y: number): Promise<ARSegmentationResult | undefined>;
+    /** Measure an object at the given screen point - combines segmentation + depth + bounding box */
+    measureObject(x: number, y: number): Promise<ARObjectMeasurement | undefined>;
 }
 export type ARView = HybridView<ARViewProps, ARViewMethods, {
     ios: "swift";

package/lib/typescript/src/specs/ARView.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ARView.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/ARView.nitro.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ARView.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/ARView.nitro.ts"],"names":[],"mappings":"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"}

package/nitrogen/generated/ios/NitroAR-Swift-Cxx-Bridge.cpp

@@ -19,6 +19,7 @@
 #include "HybridARPlaneAnchorSpecSwift.hpp"
 #include "HybridARPlaneGeometrySpecSwift.hpp"
 #include "HybridARRaycastResultSpecSwift.hpp"
+#include "HybridARSegmentationResultSpecSwift.hpp"
 #include "HybridARSessionSpecSwift.hpp"
 #include "HybridARViewSpecSwift.hpp"
 #include "HybridARVolumeSpecSwift.hpp"
@@ -156,6 +157,22 @@ namespace margelo::nitro::ar::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::shared_ptr<HybridARSegmentationResultSpec>
+  std::shared_ptr<HybridARSegmentationResultSpec> create_std__shared_ptr_HybridARSegmentationResultSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    NitroAR::HybridARSegmentationResultSpec_cxx swiftPart = NitroAR::HybridARSegmentationResultSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::ar::HybridARSegmentationResultSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridARSegmentationResultSpec_(std__shared_ptr_HybridARSegmentationResultSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::ar::HybridARSegmentationResultSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::ar::HybridARSegmentationResultSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridARSegmentationResultSpec\" is not implemented in Swift!");
+    }
+    #endif
+    NitroAR::HybridARSegmentationResultSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridARPlaneGeometrySpec>
   std::shared_ptr<HybridARPlaneGeometrySpec> create_std__shared_ptr_HybridARPlaneGeometrySpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     NitroAR::HybridARPlaneGeometrySpec_cxx swiftPart = NitroAR::HybridARPlaneGeometrySpec_cxx::fromUnsafe(swiftUnsafePointer);
@@ -316,6 +333,22 @@ namespace margelo::nitro::ar::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& /* result */)>
+  Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__ create_Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroAR::Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<ARObjectMeasurement>& /* result */)>
+  Func_void_std__optional_ARObjectMeasurement_ create_Func_void_std__optional_ARObjectMeasurement_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = NitroAR::Func_void_std__optional_ARObjectMeasurement_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::optional<ARObjectMeasurement>& result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::shared_ptr<HybridARViewSpec>
   std::shared_ptr<HybridARViewSpec> create_std__shared_ptr_HybridARViewSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     NitroAR::HybridARViewSpec_cxx swiftPart = NitroAR::HybridARViewSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `ARObjectMeasurement` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARObjectMeasurement; }
 // Forward declaration of `ARSessionConfiguration` to properly resolve imports.
 namespace margelo::nitro::ar { struct ARSessionConfiguration; }
 // Forward declaration of `ARViewHitResult` to properly resolve imports.
@@ -38,6 +40,8 @@ namespace margelo::nitro::ar { class HybridARPlaneAnchorSpec; }
 namespace margelo::nitro::ar { class HybridARPlaneGeometrySpec; }
 // Forward declaration of `HybridARRaycastResultSpec` to properly resolve imports.
 namespace margelo::nitro::ar { class HybridARRaycastResultSpec; }
+// Forward declaration of `HybridARSegmentationResultSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARSegmentationResultSpec; }
 // Forward declaration of `HybridARSessionSpec` to properly resolve imports.
 namespace margelo::nitro::ar { class HybridARSessionSpec; }
 // Forward declaration of `HybridARViewSpec` to properly resolve imports.
@@ -84,6 +88,8 @@ namespace NitroAR { class HybridARPlaneAnchorSpec_cxx; }
 namespace NitroAR { class HybridARPlaneGeometrySpec_cxx; }
 // Forward declaration of `HybridARRaycastResultSpec_cxx` to properly resolve imports.
 namespace NitroAR { class HybridARRaycastResultSpec_cxx; }
+// Forward declaration of `HybridARSegmentationResultSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARSegmentationResultSpec_cxx; }
 // Forward declaration of `HybridARSessionSpec_cxx` to properly resolve imports.
 namespace NitroAR { class HybridARSessionSpec_cxx; }
 // Forward declaration of `HybridARViewSpec_cxx` to properly resolve imports.
@@ -94,6 +100,7 @@ namespace NitroAR { class HybridARVolumeSpec_cxx; }
 namespace NitroAR { class HybridARWorldMapSpec_cxx; }
 
 // Include C++ defined types
+#include "ARObjectMeasurement.hpp"
 #include "ARSessionConfiguration.hpp"
 #include "ARViewHitResult.hpp"
 #include "CameraPose.hpp"
@@ -109,6 +116,7 @@ namespace NitroAR { class HybridARWorldMapSpec_cxx; }
 #include "HybridARPlaneAnchorSpec.hpp"
 #include "HybridARPlaneGeometrySpec.hpp"
 #include "HybridARRaycastResultSpec.hpp"
+#include "HybridARSegmentationResultSpec.hpp"
 #include "HybridARSessionSpec.hpp"
 #include "HybridARViewSpec.hpp"
 #include "HybridARVolumeSpec.hpp"
@@ -342,6 +350,51 @@ namespace margelo::nitro::ar::bridge::swift {
   using std__weak_ptr_HybridARMeasurementSpec_ = std::weak_ptr<HybridARMeasurementSpec>;
   inline std__weak_ptr_HybridARMeasurementSpec_ weakify_std__shared_ptr_HybridARMeasurementSpec_(const std::shared_ptr<HybridARMeasurementSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: std::optional<ARObjectMeasurement>
+  /**
+   * Specialized version of `std::optional<ARObjectMeasurement>`.
+   */
+  using std__optional_ARObjectMeasurement_ = std::optional<ARObjectMeasurement>;
+  inline std::optional<ARObjectMeasurement> create_std__optional_ARObjectMeasurement_(const ARObjectMeasurement& value) noexcept {
+    return std::optional<ARObjectMeasurement>(value);
+  }
+  inline bool has_value_std__optional_ARObjectMeasurement_(const std::optional<ARObjectMeasurement>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ARObjectMeasurement get_std__optional_ARObjectMeasurement_(const std::optional<ARObjectMeasurement>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridARSegmentationResultSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridARSegmentationResultSpec>`.
+   */
+  using std__shared_ptr_HybridARSegmentationResultSpec_ = std::shared_ptr<HybridARSegmentationResultSpec>;
+  std::shared_ptr<HybridARSegmentationResultSpec> create_std__shared_ptr_HybridARSegmentationResultSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridARSegmentationResultSpec_(std__shared_ptr_HybridARSegmentationResultSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridARSegmentationResultSpec>
+  using std__weak_ptr_HybridARSegmentationResultSpec_ = std::weak_ptr<HybridARSegmentationResultSpec>;
+  inline std__weak_ptr_HybridARSegmentationResultSpec_ weakify_std__shared_ptr_HybridARSegmentationResultSpec_(const std::shared_ptr<HybridARSegmentationResultSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::vector<double>>
+  using Result_std__vector_double__ = Result<std::vector<double>>;
+  inline Result_std__vector_double__ create_Result_std__vector_double__(const std::vector<double>& value) noexcept {
+    return Result<std::vector<double>>::withValue(value);
+  }
+  inline Result_std__vector_double__ create_Result_std__vector_double__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<double>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<ARObjectMeasurement>>
+  using Result_std__optional_ARObjectMeasurement__ = Result<std::optional<ARObjectMeasurement>>;
+  inline Result_std__optional_ARObjectMeasurement__ create_Result_std__optional_ARObjectMeasurement__(const std::optional<ARObjectMeasurement>& value) noexcept {
+    return Result<std::optional<ARObjectMeasurement>>::withValue(value);
+  }
+  inline Result_std__optional_ARObjectMeasurement__ create_Result_std__optional_ARObjectMeasurement__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<ARObjectMeasurement>>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<HybridARPlaneGeometrySpec>
   /**
    * Specialized version of `std::shared_ptr<HybridARPlaneGeometrySpec>`.
@@ -901,6 +954,89 @@ namespace margelo::nitro::ar::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>`.
+   */
+  using std__optional_std__shared_ptr_HybridARSegmentationResultSpec__ = std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>;
+  inline std::optional<std::shared_ptr<HybridARSegmentationResultSpec>> create_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__(const std::shared_ptr<HybridARSegmentationResultSpec>& value) noexcept {
+    return std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<HybridARSegmentationResultSpec> get_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec____ = std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>;
+  inline std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>> create_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec____() noexcept {
+    return Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>::create();
+  }
+  inline PromiseHolder<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>> wrap_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec____(std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>> promise) noexcept {
+    return PromiseHolder<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>&)>`.
+   */
+  using Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__ = std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec___Wrapper final {
+  public:
+    explicit Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec___Wrapper(std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<std::shared_ptr<HybridARSegmentationResultSpec>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__ create_Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec___Wrapper wrap_Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__(Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec__ value) noexcept {
+    return Func_void_std__optional_std__shared_ptr_HybridARSegmentationResultSpec___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_ARObjectMeasurement___ = std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>;
+  inline std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>> create_std__shared_ptr_Promise_std__optional_ARObjectMeasurement___() noexcept {
+    return Promise<std::optional<ARObjectMeasurement>>::create();
+  }
+  inline PromiseHolder<std::optional<ARObjectMeasurement>> wrap_std__shared_ptr_Promise_std__optional_ARObjectMeasurement___(std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>> promise) noexcept {
+    return PromiseHolder<std::optional<ARObjectMeasurement>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<ARObjectMeasurement>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<ARObjectMeasurement>&)>`.
+   */
+  using Func_void_std__optional_ARObjectMeasurement_ = std::function<void(const std::optional<ARObjectMeasurement>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<ARObjectMeasurement>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_ARObjectMeasurement__Wrapper final {
+  public:
+    explicit Func_void_std__optional_ARObjectMeasurement__Wrapper(std::function<void(const std::optional<ARObjectMeasurement>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::optional<ARObjectMeasurement>& /* result */)>>(std::move(func))) {}
+    inline void call(std::optional<ARObjectMeasurement> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<ARObjectMeasurement>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_ARObjectMeasurement_ create_Func_void_std__optional_ARObjectMeasurement_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_ARObjectMeasurement__Wrapper wrap_Func_void_std__optional_ARObjectMeasurement_(Func_void_std__optional_ARObjectMeasurement_ value) noexcept {
+    return Func_void_std__optional_ARObjectMeasurement__Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridARViewSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridARViewSpec>`.
@@ -930,5 +1066,23 @@ namespace margelo::nitro::ar::bridge::swift {
   inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
     return Result<bool>::withError(error);
   }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>>
+  using Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec_____ = Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec_____ create_Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec_____(const std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec_____ create_Result_std__shared_ptr_Promise_std__optional_std__shared_ptr_HybridARSegmentationResultSpec_____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>>
+  using Result_std__shared_ptr_Promise_std__optional_ARObjectMeasurement____ = Result<std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>>;
+  inline Result_std__shared_ptr_Promise_std__optional_ARObjectMeasurement____ create_Result_std__shared_ptr_Promise_std__optional_ARObjectMeasurement____(const std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__optional_ARObjectMeasurement____ create_Result_std__shared_ptr_Promise_std__optional_ARObjectMeasurement____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::ar::bridge::swift

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

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `ARObjectMeasurement` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARObjectMeasurement; }
 // Forward declaration of `ARSessionConfiguration` to properly resolve imports.
 namespace margelo::nitro::ar { struct ARSessionConfiguration; }
 // Forward declaration of `ARViewHitResult` to properly resolve imports.
@@ -38,6 +40,8 @@ namespace margelo::nitro::ar { class HybridARPlaneAnchorSpec; }
 namespace margelo::nitro::ar { class HybridARPlaneGeometrySpec; }
 // Forward declaration of `HybridARRaycastResultSpec` to properly resolve imports.
 namespace margelo::nitro::ar { class HybridARRaycastResultSpec; }
+// Forward declaration of `HybridARSegmentationResultSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARSegmentationResultSpec; }
 // Forward declaration of `HybridARSessionSpec` to properly resolve imports.
 namespace margelo::nitro::ar { class HybridARSessionSpec; }
 // Forward declaration of `HybridARViewSpec` to properly resolve imports.
@@ -74,6 +78,7 @@ namespace margelo::nitro::ar { enum class WorldAlignment; }
 namespace margelo::nitro::ar { enum class WorldMappingStatus; }
 
 // Include C++ defined types
+#include "ARObjectMeasurement.hpp"
 #include "ARSessionConfiguration.hpp"
 #include "ARViewHitResult.hpp"
 #include "CameraPose.hpp"
@@ -89,6 +94,7 @@ namespace margelo::nitro::ar { enum class WorldMappingStatus; }
 #include "HybridARPlaneAnchorSpec.hpp"
 #include "HybridARPlaneGeometrySpec.hpp"
 #include "HybridARRaycastResultSpec.hpp"
+#include "HybridARSegmentationResultSpec.hpp"
 #include "HybridARSessionSpec.hpp"
 #include "HybridARViewSpec.hpp"
 #include "HybridARVolumeSpec.hpp"
@@ -147,6 +153,8 @@ namespace NitroAR { class HybridARPlaneAnchorSpec_cxx; }
 namespace NitroAR { class HybridARPlaneGeometrySpec_cxx; }
 // Forward declaration of `HybridARRaycastResultSpec_cxx` to properly resolve imports.
 namespace NitroAR { class HybridARRaycastResultSpec_cxx; }
+// Forward declaration of `HybridARSegmentationResultSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARSegmentationResultSpec_cxx; }
 // Forward declaration of `HybridARSessionSpec_cxx` to properly resolve imports.
 namespace NitroAR { class HybridARSessionSpec_cxx; }
 // Forward declaration of `HybridARViewSpec_cxx` to properly resolve imports.

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

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

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

@@ -0,0 +1,102 @@
+///
+/// HybridARSegmentationResultSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridARSegmentationResultSpec.hpp"
+
+// Forward declaration of `HybridARSegmentationResultSpec_cxx` to properly resolve imports.
+namespace NitroAR { class HybridARSegmentationResultSpec_cxx; }
+
+// Forward declaration of `ARObjectMeasurement` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARObjectMeasurement; }
+
+#include <vector>
+#include "ARObjectMeasurement.hpp"
+#include <optional>
+
+#include "NitroAR-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::ar {
+
+  /**
+   * The C++ part of HybridARSegmentationResultSpec_cxx.swift.
+   *
+   * HybridARSegmentationResultSpecSwift (C++) accesses HybridARSegmentationResultSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridARSegmentationResultSpec_cxx can directly inherit from the C++ class HybridARSegmentationResultSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridARSegmentationResultSpecSwift: public virtual HybridARSegmentationResultSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridARSegmentationResultSpecSwift(const NitroAR::HybridARSegmentationResultSpec_cxx& swiftPart):
+      HybridObject(HybridARSegmentationResultSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroAR::HybridARSegmentationResultSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridARSegmentationResultSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline bool getSuccess() noexcept override {
+      return _swiftPart.getSuccess();
+    }
+    inline std::vector<double> getBoundingBox() noexcept override {
+      auto __result = _swiftPart.getBoundingBox();
+      return __result;
+    }
+    inline double getMaskPixelCount() noexcept override {
+      return _swiftPart.getMaskPixelCount();
+    }
+
+  public:
+    // Methods
+    inline std::vector<double> getDepthPoints() override {
+      auto __result = _swiftPart.getDepthPoints();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<ARObjectMeasurement> measure() override {
+      auto __result = _swiftPart.measure();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroAR::HybridARSegmentationResultSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::ar

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

@@ -16,11 +16,20 @@ namespace NitroAR { class HybridARViewSpec_cxx; }
 namespace margelo::nitro::ar { enum class SceneReconstructionMode; }
 // Forward declaration of `ARViewHitResult` to properly resolve imports.
 namespace margelo::nitro::ar { struct ARViewHitResult; }
+// Forward declaration of `HybridARSegmentationResultSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARSegmentationResultSpec; }
+// Forward declaration of `ARObjectMeasurement` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARObjectMeasurement; }
 
 #include <optional>
 #include "SceneReconstructionMode.hpp"
 #include <string>
 #include "ARViewHitResult.hpp"
+#include <memory>
+#include "HybridARSegmentationResultSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "ARObjectMeasurement.hpp"
+#include <vector>
 
 #include "NitroAR-Swift-Cxx-Umbrella.hpp"
 
@@ -235,6 +244,22 @@ namespace margelo::nitro::ar {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<std::optional<std::shared_ptr<HybridARSegmentationResultSpec>>>> segmentObject(double x, double y) override {
+      auto __result = _swiftPart.segmentObject(std::forward<decltype(x)>(x), std::forward<decltype(y)>(y));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::optional<ARObjectMeasurement>>> measureObject(double x, double y) override {
+      auto __result = _swiftPart.measureObject(std::forward<decltype(x)>(x), std::forward<decltype(y)>(y));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroAR::HybridARViewSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/ARObjectMeasurement.swift

@@ -0,0 +1,71 @@
+///
+/// ARObjectMeasurement.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `ARObjectMeasurement`, backed by a C++ struct.
+ */
+public typealias ARObjectMeasurement = margelo.nitro.ar.ARObjectMeasurement
+
+public extension ARObjectMeasurement {
+  private typealias bridge = margelo.nitro.ar.bridge.swift
+
+  /**
+   * Create a new instance of `ARObjectMeasurement`.
+   */
+  init(width: Double, height: Double, depth: Double, center: [Double], axes: [Double], confidence: Double, pointCount: Double) {
+    self.init(width, height, depth, { () -> bridge.std__vector_double_ in
+      var __vector = bridge.create_std__vector_double_(center.count)
+      for __item in center {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }(), { () -> bridge.std__vector_double_ in
+      var __vector = bridge.create_std__vector_double_(axes.count)
+      for __item in axes {
+        __vector.push_back(__item)
+      }
+      return __vector
+    }(), confidence, pointCount)
+  }
+
+  @inline(__always)
+  var width: Double {
+    return self.__width
+  }
+  
+  @inline(__always)
+  var height: Double {
+    return self.__height
+  }
+  
+  @inline(__always)
+  var depth: Double {
+    return self.__depth
+  }
+  
+  @inline(__always)
+  var center: [Double] {
+    return self.__center.map({ __item in __item })
+  }
+  
+  @inline(__always)
+  var axes: [Double] {
+    return self.__axes.map({ __item in __item })
+  }
+  
+  @inline(__always)
+  var confidence: Double {
+    return self.__confidence
+  }
+  
+  @inline(__always)
+  var pointCount: Double {
+    return self.__pointCount
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__optional_ARObjectMeasurement_.swift

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