react-native-nitro-ar 2026.2.1

package/nitrogen/generated/shared/c++/HybridARSessionSpec.hpp

@@ -0,0 +1,131 @@
+///
+/// HybridARSessionSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `TrackingState` to properly resolve imports.
+namespace margelo::nitro::ar { enum class TrackingState; }
+// Forward declaration of `TrackingStateReason` to properly resolve imports.
+namespace margelo::nitro::ar { enum class TrackingStateReason; }
+// Forward declaration of `WorldMappingStatus` to properly resolve imports.
+namespace margelo::nitro::ar { enum class WorldMappingStatus; }
+// Forward declaration of `HybridARFrameSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARFrameSpec; }
+// Forward declaration of `HybridARAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARAnchorSpec; }
+// Forward declaration of `HybridARPlaneAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARPlaneAnchorSpec; }
+// Forward declaration of `HybridARMeshAnchorSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARMeshAnchorSpec; }
+// Forward declaration of `ARSessionConfiguration` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARSessionConfiguration; }
+// Forward declaration of `CameraPose` to properly resolve imports.
+namespace margelo::nitro::ar { struct CameraPose; }
+// Forward declaration of `HybridARRaycastResultSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARRaycastResultSpec; }
+// Forward declaration of `RaycastQuery` to properly resolve imports.
+namespace margelo::nitro::ar { struct RaycastQuery; }
+// Forward declaration of `HybridARMeasurementSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARMeasurementSpec; }
+// Forward declaration of `HybridARWorldMapSpec` to properly resolve imports.
+namespace margelo::nitro::ar { class HybridARWorldMapSpec; }
+// Forward declaration of `LiDARCapabilities` to properly resolve imports.
+namespace margelo::nitro::ar { struct LiDARCapabilities; }
+
+#include "TrackingState.hpp"
+#include "TrackingStateReason.hpp"
+#include "WorldMappingStatus.hpp"
+#include <memory>
+#include "HybridARFrameSpec.hpp"
+#include <optional>
+#include "HybridARAnchorSpec.hpp"
+#include <vector>
+#include "HybridARPlaneAnchorSpec.hpp"
+#include "HybridARMeshAnchorSpec.hpp"
+#include "ARSessionConfiguration.hpp"
+#include "CameraPose.hpp"
+#include "HybridARRaycastResultSpec.hpp"
+#include "RaycastQuery.hpp"
+#include "HybridARMeasurementSpec.hpp"
+#include "HybridARWorldMapSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <functional>
+#include <string>
+#include "LiDARCapabilities.hpp"
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARSession`
+   * Inherit this class to create instances of `HybridARSessionSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARSession: public HybridARSessionSpec {
+   * public:
+   *   HybridARSession(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARSessionSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARSessionSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARSessionSpec() override = default;
+
+    public:
+      // Properties
+      virtual TrackingState getTrackingState() = 0;
+      virtual TrackingStateReason getTrackingStateReason() = 0;
+      virtual WorldMappingStatus getWorldMappingStatus() = 0;
+      virtual bool getIsRunning() = 0;
+      virtual std::optional<std::shared_ptr<HybridARFrameSpec>> getCurrentFrame() = 0;
+      virtual std::vector<std::shared_ptr<HybridARAnchorSpec>> getAnchors() = 0;
+      virtual std::vector<std::shared_ptr<HybridARPlaneAnchorSpec>> getPlaneAnchors() = 0;
+      virtual std::vector<std::shared_ptr<HybridARMeshAnchorSpec>> getMeshAnchors() = 0;
+
+    public:
+      // Methods
+      virtual void start(const std::optional<ARSessionConfiguration>& config) = 0;
+      virtual void pause() = 0;
+      virtual void reset() = 0;
+      virtual CameraPose getCameraPose() = 0;
+      virtual std::optional<std::shared_ptr<HybridARRaycastResultSpec>> raycast(double x, double y) = 0;
+      virtual std::vector<std::shared_ptr<HybridARRaycastResultSpec>> raycastWithQuery(const RaycastQuery& query) = 0;
+      virtual std::shared_ptr<HybridARAnchorSpec> createAnchor(const std::shared_ptr<HybridARRaycastResultSpec>& hit) = 0;
+      virtual std::shared_ptr<HybridARAnchorSpec> createAnchorAtPosition(const std::vector<double>& position, const std::optional<std::vector<double>>& rotation) = 0;
+      virtual void removeAnchor(const std::shared_ptr<HybridARAnchorSpec>& anchor) = 0;
+      virtual std::shared_ptr<HybridARMeasurementSpec> createMeasurement(const std::shared_ptr<HybridARAnchorSpec>& start, const std::shared_ptr<HybridARAnchorSpec>& end) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<HybridARWorldMapSpec>>> getCurrentWorldMap() = 0;
+      virtual std::function<void()> onFrameUpdate(const std::function<void(const std::shared_ptr<HybridARFrameSpec>& /* frame */)>& callback) = 0;
+      virtual std::function<void()> onTrackingStateChanged(const std::function<void(TrackingState /* state */, TrackingStateReason /* reason */)>& callback) = 0;
+      virtual std::function<void()> onAnchorsUpdated(const std::function<void(const std::vector<std::shared_ptr<HybridARAnchorSpec>>& /* added */, const std::vector<std::shared_ptr<HybridARAnchorSpec>>& /* updated */, const std::vector<std::string>& /* removed */)>& callback) = 0;
+      virtual std::function<void()> onPlanesUpdated(const std::function<void(const std::vector<std::shared_ptr<HybridARPlaneAnchorSpec>>& /* added */, const std::vector<std::shared_ptr<HybridARPlaneAnchorSpec>>& /* updated */, const std::vector<std::string>& /* removed */)>& callback) = 0;
+      virtual LiDARCapabilities getLiDARCapabilities() = 0;
+      virtual std::function<void()> onMeshUpdated(const std::function<void(const std::vector<std::shared_ptr<HybridARMeshAnchorSpec>>& /* added */, const std::vector<std::shared_ptr<HybridARMeshAnchorSpec>>& /* updated */, const std::vector<std::string>& /* removed */)>& callback) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARSession";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARViewSpec.cpp

@@ -0,0 +1,55 @@
+///
+/// HybridARViewSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARViewSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARViewSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("showDebugOptions", &HybridARViewSpec::getShowDebugOptions);
+      prototype.registerHybridSetter("showDebugOptions", &HybridARViewSpec::setShowDebugOptions);
+      prototype.registerHybridGetter("showPlanes", &HybridARViewSpec::getShowPlanes);
+      prototype.registerHybridSetter("showPlanes", &HybridARViewSpec::setShowPlanes);
+      prototype.registerHybridGetter("showFeaturePoints", &HybridARViewSpec::getShowFeaturePoints);
+      prototype.registerHybridSetter("showFeaturePoints", &HybridARViewSpec::setShowFeaturePoints);
+      prototype.registerHybridGetter("showWorldOrigin", &HybridARViewSpec::getShowWorldOrigin);
+      prototype.registerHybridSetter("showWorldOrigin", &HybridARViewSpec::setShowWorldOrigin);
+      prototype.registerHybridGetter("autoenablesDefaultLighting", &HybridARViewSpec::getAutoenablesDefaultLighting);
+      prototype.registerHybridSetter("autoenablesDefaultLighting", &HybridARViewSpec::setAutoenablesDefaultLighting);
+      prototype.registerHybridGetter("sceneReconstruction", &HybridARViewSpec::getSceneReconstruction);
+      prototype.registerHybridSetter("sceneReconstruction", &HybridARViewSpec::setSceneReconstruction);
+      prototype.registerHybridGetter("showSceneMesh", &HybridARViewSpec::getShowSceneMesh);
+      prototype.registerHybridSetter("showSceneMesh", &HybridARViewSpec::setShowSceneMesh);
+      prototype.registerHybridGetter("sceneDepth", &HybridARViewSpec::getSceneDepth);
+      prototype.registerHybridSetter("sceneDepth", &HybridARViewSpec::setSceneDepth);
+      prototype.registerHybridGetter("objectOcclusion", &HybridARViewSpec::getObjectOcclusion);
+      prototype.registerHybridSetter("objectOcclusion", &HybridARViewSpec::setObjectOcclusion);
+      prototype.registerHybridGetter("peopleOcclusion", &HybridARViewSpec::getPeopleOcclusion);
+      prototype.registerHybridSetter("peopleOcclusion", &HybridARViewSpec::setPeopleOcclusion);
+      prototype.registerHybridMethod("addMeasurementPoint", &HybridARViewSpec::addMeasurementPoint);
+      prototype.registerHybridMethod("removeMeasurementPoint", &HybridARViewSpec::removeMeasurementPoint);
+      prototype.registerHybridMethod("updateMeasurementPoint", &HybridARViewSpec::updateMeasurementPoint);
+      prototype.registerHybridMethod("addLine", &HybridARViewSpec::addLine);
+      prototype.registerHybridMethod("updateLine", &HybridARViewSpec::updateLine);
+      prototype.registerHybridMethod("removeLine", &HybridARViewSpec::removeLine);
+      prototype.registerHybridMethod("addDistanceLabel", &HybridARViewSpec::addDistanceLabel);
+      prototype.registerHybridMethod("updateDistanceLabel", &HybridARViewSpec::updateDistanceLabel);
+      prototype.registerHybridMethod("removeDistanceLabel", &HybridARViewSpec::removeDistanceLabel);
+      prototype.registerHybridMethod("clearAllVisuals", &HybridARViewSpec::clearAllVisuals);
+      prototype.registerHybridMethod("raycast", &HybridARViewSpec::raycast);
+      prototype.registerHybridMethod("startSession", &HybridARViewSpec::startSession);
+      prototype.registerHybridMethod("pauseSession", &HybridARViewSpec::pauseSession);
+      prototype.registerHybridMethod("resetSession", &HybridARViewSpec::resetSession);
+      prototype.registerHybridMethod("isLiDARAvailable", &HybridARViewSpec::isLiDARAvailable);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARViewSpec.hpp

@@ -0,0 +1,101 @@
+///
+/// HybridARViewSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `SceneReconstructionMode` to properly resolve imports.
+namespace margelo::nitro::ar { enum class SceneReconstructionMode; }
+// Forward declaration of `ARViewHitResult` to properly resolve imports.
+namespace margelo::nitro::ar { struct ARViewHitResult; }
+
+#include <optional>
+#include "SceneReconstructionMode.hpp"
+#include <string>
+#include "ARViewHitResult.hpp"
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARView`
+   * Inherit this class to create instances of `HybridARViewSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARView: public HybridARViewSpec {
+   * public:
+   *   HybridARView(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARViewSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARViewSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARViewSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<bool> getShowDebugOptions() = 0;
+      virtual void setShowDebugOptions(std::optional<bool> showDebugOptions) = 0;
+      virtual std::optional<bool> getShowPlanes() = 0;
+      virtual void setShowPlanes(std::optional<bool> showPlanes) = 0;
+      virtual std::optional<bool> getShowFeaturePoints() = 0;
+      virtual void setShowFeaturePoints(std::optional<bool> showFeaturePoints) = 0;
+      virtual std::optional<bool> getShowWorldOrigin() = 0;
+      virtual void setShowWorldOrigin(std::optional<bool> showWorldOrigin) = 0;
+      virtual std::optional<bool> getAutoenablesDefaultLighting() = 0;
+      virtual void setAutoenablesDefaultLighting(std::optional<bool> autoenablesDefaultLighting) = 0;
+      virtual std::optional<SceneReconstructionMode> getSceneReconstruction() = 0;
+      virtual void setSceneReconstruction(std::optional<SceneReconstructionMode> sceneReconstruction) = 0;
+      virtual std::optional<bool> getShowSceneMesh() = 0;
+      virtual void setShowSceneMesh(std::optional<bool> showSceneMesh) = 0;
+      virtual std::optional<bool> getSceneDepth() = 0;
+      virtual void setSceneDepth(std::optional<bool> sceneDepth) = 0;
+      virtual std::optional<bool> getObjectOcclusion() = 0;
+      virtual void setObjectOcclusion(std::optional<bool> objectOcclusion) = 0;
+      virtual std::optional<bool> getPeopleOcclusion() = 0;
+      virtual void setPeopleOcclusion(std::optional<bool> peopleOcclusion) = 0;
+
+    public:
+      // Methods
+      virtual void addMeasurementPoint(const std::string& id, double x, double y, double z, const std::optional<std::string>& color) = 0;
+      virtual void removeMeasurementPoint(const std::string& id) = 0;
+      virtual void updateMeasurementPoint(const std::string& id, double x, double y, double z) = 0;
+      virtual void addLine(const std::string& id, double fromX, double fromY, double fromZ, double toX, double toY, double toZ, const std::optional<std::string>& color) = 0;
+      virtual void updateLine(const std::string& id, double fromX, double fromY, double fromZ, double toX, double toY, double toZ) = 0;
+      virtual void removeLine(const std::string& id) = 0;
+      virtual void addDistanceLabel(const std::string& id, double x, double y, double z, double distance) = 0;
+      virtual void updateDistanceLabel(const std::string& id, double x, double y, double z, double distance) = 0;
+      virtual void removeDistanceLabel(const std::string& id) = 0;
+      virtual void clearAllVisuals() = 0;
+      virtual std::optional<ARViewHitResult> raycast(double x, double y) = 0;
+      virtual void startSession() = 0;
+      virtual void pauseSession() = 0;
+      virtual void resetSession() = 0;
+      virtual bool isLiDARAvailable() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARView";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARVolumeSpec.cpp

@@ -0,0 +1,26 @@
+///
+/// HybridARVolumeSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARVolumeSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARVolumeSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("center", &HybridARVolumeSpec::getCenter);
+      prototype.registerHybridGetter("width", &HybridARVolumeSpec::getWidth);
+      prototype.registerHybridGetter("height", &HybridARVolumeSpec::getHeight);
+      prototype.registerHybridGetter("depth", &HybridARVolumeSpec::getDepth);
+      prototype.registerHybridGetter("rotation", &HybridARVolumeSpec::getRotation);
+      prototype.registerHybridGetter("isStable", &HybridARVolumeSpec::getIsStable);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARVolumeSpec.hpp

@@ -0,0 +1,67 @@
+///
+/// HybridARVolumeSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <vector>
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARVolume`
+   * Inherit this class to create instances of `HybridARVolumeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARVolume: public HybridARVolumeSpec {
+   * public:
+   *   HybridARVolume(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARVolumeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARVolumeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARVolumeSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::vector<double> getCenter() = 0;
+      virtual double getWidth() = 0;
+      virtual double getHeight() = 0;
+      virtual double getDepth() = 0;
+      virtual std::vector<double> getRotation() = 0;
+      virtual bool getIsStable() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARVolume";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARWorldMapSpec.cpp

@@ -0,0 +1,25 @@
+///
+/// HybridARWorldMapSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridARWorldMapSpec.hpp"
+
+namespace margelo::nitro::ar {
+
+  void HybridARWorldMapSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("identifier", &HybridARWorldMapSpec::getIdentifier);
+      prototype.registerHybridGetter("center", &HybridARWorldMapSpec::getCenter);
+      prototype.registerHybridGetter("extent", &HybridARWorldMapSpec::getExtent);
+      prototype.registerHybridGetter("anchorCount", &HybridARWorldMapSpec::getAnchorCount);
+      prototype.registerHybridMethod("getData", &HybridARWorldMapSpec::getData);
+    });
+  }
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/HybridARWorldMapSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridARWorldMapSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::ar {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ARWorldMap`
+   * Inherit this class to create instances of `HybridARWorldMapSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridARWorldMap: public HybridARWorldMapSpec {
+   * public:
+   *   HybridARWorldMap(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridARWorldMapSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridARWorldMapSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridARWorldMapSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getIdentifier() = 0;
+      virtual std::vector<double> getCenter() = 0;
+      virtual std::vector<double> getExtent() = 0;
+      virtual double getAnchorCount() = 0;
+
+    public:
+      // Methods
+      virtual std::string getData() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ARWorldMap";
+  };
+
+} // namespace margelo::nitro::ar

package/nitrogen/generated/shared/c++/LiDARCapabilities.hpp

@@ -0,0 +1,91 @@
+///
+/// LiDARCapabilities.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::ar {
+
+  /**
+   * A struct which can be represented as a JavaScript object (LiDARCapabilities).
+   */
+  struct LiDARCapabilities final {
+  public:
+    bool isAvailable     SWIFT_PRIVATE;
+    bool supportsSceneReconstruction     SWIFT_PRIVATE;
+    bool supportsSceneDepth     SWIFT_PRIVATE;
+
+  public:
+    LiDARCapabilities() = default;
+    explicit LiDARCapabilities(bool isAvailable, bool supportsSceneReconstruction, bool supportsSceneDepth): isAvailable(isAvailable), supportsSceneReconstruction(supportsSceneReconstruction), supportsSceneDepth(supportsSceneDepth) {}
+
+  public:
+    friend bool operator==(const LiDARCapabilities& lhs, const LiDARCapabilities& rhs) = default;
+  };
+
+} // namespace margelo::nitro::ar
+
+namespace margelo::nitro {
+
+  // C++ LiDARCapabilities <> JS LiDARCapabilities (object)
+  template <>
+  struct JSIConverter<margelo::nitro::ar::LiDARCapabilities> final {
+    static inline margelo::nitro::ar::LiDARCapabilities fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::ar::LiDARCapabilities(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isAvailable"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "supportsSceneReconstruction"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "supportsSceneDepth")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::ar::LiDARCapabilities& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isAvailable"), JSIConverter<bool>::toJSI(runtime, arg.isAvailable));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "supportsSceneReconstruction"), JSIConverter<bool>::toJSI(runtime, arg.supportsSceneReconstruction));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "supportsSceneDepth"), JSIConverter<bool>::toJSI(runtime, arg.supportsSceneDepth));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isAvailable")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "supportsSceneReconstruction")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "supportsSceneDepth")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/MeshClassification.hpp

@@ -0,0 +1,100 @@
+///
+/// MeshClassification.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::ar {
+
+  /**
+   * An enum which can be represented as a JavaScript union (MeshClassification).
+   */
+  enum class MeshClassification {
+    NONE      SWIFT_NAME(none) = 0,
+    WALL      SWIFT_NAME(wall) = 1,
+    FLOOR      SWIFT_NAME(floor) = 2,
+    CEILING      SWIFT_NAME(ceiling) = 3,
+    TABLE      SWIFT_NAME(table) = 4,
+    SEAT      SWIFT_NAME(seat) = 5,
+    WINDOW      SWIFT_NAME(window) = 6,
+    DOOR      SWIFT_NAME(door) = 7,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::ar
+
+namespace margelo::nitro {
+
+  // C++ MeshClassification <> JS MeshClassification (union)
+  template <>
+  struct JSIConverter<margelo::nitro::ar::MeshClassification> final {
+    static inline margelo::nitro::ar::MeshClassification fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"): return margelo::nitro::ar::MeshClassification::NONE;
+        case hashString("wall"): return margelo::nitro::ar::MeshClassification::WALL;
+        case hashString("floor"): return margelo::nitro::ar::MeshClassification::FLOOR;
+        case hashString("ceiling"): return margelo::nitro::ar::MeshClassification::CEILING;
+        case hashString("table"): return margelo::nitro::ar::MeshClassification::TABLE;
+        case hashString("seat"): return margelo::nitro::ar::MeshClassification::SEAT;
+        case hashString("window"): return margelo::nitro::ar::MeshClassification::WINDOW;
+        case hashString("door"): return margelo::nitro::ar::MeshClassification::DOOR;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum MeshClassification - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::ar::MeshClassification arg) {
+      switch (arg) {
+        case margelo::nitro::ar::MeshClassification::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        case margelo::nitro::ar::MeshClassification::WALL: return JSIConverter<std::string>::toJSI(runtime, "wall");
+        case margelo::nitro::ar::MeshClassification::FLOOR: return JSIConverter<std::string>::toJSI(runtime, "floor");
+        case margelo::nitro::ar::MeshClassification::CEILING: return JSIConverter<std::string>::toJSI(runtime, "ceiling");
+        case margelo::nitro::ar::MeshClassification::TABLE: return JSIConverter<std::string>::toJSI(runtime, "table");
+        case margelo::nitro::ar::MeshClassification::SEAT: return JSIConverter<std::string>::toJSI(runtime, "seat");
+        case margelo::nitro::ar::MeshClassification::WINDOW: return JSIConverter<std::string>::toJSI(runtime, "window");
+        case margelo::nitro::ar::MeshClassification::DOOR: return JSIConverter<std::string>::toJSI(runtime, "door");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert MeshClassification to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"):
+        case hashString("wall"):
+        case hashString("floor"):
+        case hashString("ceiling"):
+        case hashString("table"):
+        case hashString("seat"):
+        case hashString("window"):
+        case hashString("door"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro