@renegades/react-native-tickle 0.1.0

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

@@ -0,0 +1,87 @@
+///
+/// HapticCurveControlPoint.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::tickle {
+
+  /**
+   * A struct which can be represented as a JavaScript object (HapticCurveControlPoint).
+   */
+  struct HapticCurveControlPoint final {
+  public:
+    double relativeTime     SWIFT_PRIVATE;
+    double value     SWIFT_PRIVATE;
+
+  public:
+    HapticCurveControlPoint() = default;
+    explicit HapticCurveControlPoint(double relativeTime, double value): relativeTime(relativeTime), value(value) {}
+
+  public:
+    friend bool operator==(const HapticCurveControlPoint& lhs, const HapticCurveControlPoint& rhs) = default;
+  };
+
+} // namespace margelo::nitro::tickle
+
+namespace margelo::nitro {
+
+  // C++ HapticCurveControlPoint <> JS HapticCurveControlPoint (object)
+  template <>
+  struct JSIConverter<margelo::nitro::tickle::HapticCurveControlPoint> final {
+    static inline margelo::nitro::tickle::HapticCurveControlPoint fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::tickle::HapticCurveControlPoint(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "relativeTime"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "value")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::tickle::HapticCurveControlPoint& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "relativeTime"), JSIConverter<double>::toJSI(runtime, arg.relativeTime));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "value"), JSIConverter<double>::toJSI(runtime, arg.value));
+      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<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "relativeTime")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "value")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,101 @@
+///
+/// HapticEvent.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
+
+// Forward declaration of `HapticEventType` to properly resolve imports.
+namespace margelo::nitro::tickle { enum class HapticEventType; }
+// Forward declaration of `HapticEventParameter` to properly resolve imports.
+namespace margelo::nitro::tickle { struct HapticEventParameter; }
+
+#include "HapticEventType.hpp"
+#include "HapticEventParameter.hpp"
+#include <vector>
+#include <optional>
+
+namespace margelo::nitro::tickle {
+
+  /**
+   * A struct which can be represented as a JavaScript object (HapticEvent).
+   */
+  struct HapticEvent final {
+  public:
+    HapticEventType type     SWIFT_PRIVATE;
+    std::vector<HapticEventParameter> parameters     SWIFT_PRIVATE;
+    double relativeTime     SWIFT_PRIVATE;
+    std::optional<double> duration     SWIFT_PRIVATE;
+
+  public:
+    HapticEvent() = default;
+    explicit HapticEvent(HapticEventType type, std::vector<HapticEventParameter> parameters, double relativeTime, std::optional<double> duration): type(type), parameters(parameters), relativeTime(relativeTime), duration(duration) {}
+
+  public:
+    friend bool operator==(const HapticEvent& lhs, const HapticEvent& rhs) = default;
+  };
+
+} // namespace margelo::nitro::tickle
+
+namespace margelo::nitro {
+
+  // C++ HapticEvent <> JS HapticEvent (object)
+  template <>
+  struct JSIConverter<margelo::nitro::tickle::HapticEvent> final {
+    static inline margelo::nitro::tickle::HapticEvent fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::tickle::HapticEvent(
+        JSIConverter<margelo::nitro::tickle::HapticEventType>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "type"))),
+        JSIConverter<std::vector<margelo::nitro::tickle::HapticEventParameter>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "parameters"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "relativeTime"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "duration")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::tickle::HapticEvent& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "type"), JSIConverter<margelo::nitro::tickle::HapticEventType>::toJSI(runtime, arg.type));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "parameters"), JSIConverter<std::vector<margelo::nitro::tickle::HapticEventParameter>>::toJSI(runtime, arg.parameters));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "relativeTime"), JSIConverter<double>::toJSI(runtime, arg.relativeTime));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "duration"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.duration));
+      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<margelo::nitro::tickle::HapticEventType>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "type")))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::tickle::HapticEventParameter>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "parameters")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "relativeTime")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "duration")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,88 @@
+///
+/// HapticEventParameter.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
+
+// Forward declaration of `HapticParameterType` to properly resolve imports.
+namespace margelo::nitro::tickle { enum class HapticParameterType; }
+
+#include "HapticParameterType.hpp"
+
+namespace margelo::nitro::tickle {
+
+  /**
+   * A struct which can be represented as a JavaScript object (HapticEventParameter).
+   */
+  struct HapticEventParameter final {
+  public:
+    HapticParameterType type     SWIFT_PRIVATE;
+    double value     SWIFT_PRIVATE;
+
+  public:
+    HapticEventParameter() = default;
+    explicit HapticEventParameter(HapticParameterType type, double value): type(type), value(value) {}
+
+  public:
+    friend bool operator==(const HapticEventParameter& lhs, const HapticEventParameter& rhs) = default;
+  };
+
+} // namespace margelo::nitro::tickle
+
+namespace margelo::nitro {
+
+  // C++ HapticEventParameter <> JS HapticEventParameter (object)
+  template <>
+  struct JSIConverter<margelo::nitro::tickle::HapticEventParameter> final {
+    static inline margelo::nitro::tickle::HapticEventParameter fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::tickle::HapticEventParameter(
+        JSIConverter<margelo::nitro::tickle::HapticParameterType>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "type"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "value")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::tickle::HapticEventParameter& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "type"), JSIConverter<margelo::nitro::tickle::HapticParameterType>::toJSI(runtime, arg.type));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "value"), JSIConverter<double>::toJSI(runtime, arg.value));
+      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<margelo::nitro::tickle::HapticParameterType>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "type")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "value")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,76 @@
+///
+/// HapticEventType.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::tickle {
+
+  /**
+   * An enum which can be represented as a JavaScript union (HapticEventType).
+   */
+  enum class HapticEventType {
+    TRANSIENT      SWIFT_NAME(transient) = 0,
+    CONTINUOUS      SWIFT_NAME(continuous) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::tickle
+
+namespace margelo::nitro {
+
+  // C++ HapticEventType <> JS HapticEventType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::tickle::HapticEventType> final {
+    static inline margelo::nitro::tickle::HapticEventType 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("transient"): return margelo::nitro::tickle::HapticEventType::TRANSIENT;
+        case hashString("continuous"): return margelo::nitro::tickle::HapticEventType::CONTINUOUS;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum HapticEventType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::tickle::HapticEventType arg) {
+      switch (arg) {
+        case margelo::nitro::tickle::HapticEventType::TRANSIENT: return JSIConverter<std::string>::toJSI(runtime, "transient");
+        case margelo::nitro::tickle::HapticEventType::CONTINUOUS: return JSIConverter<std::string>::toJSI(runtime, "continuous");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert HapticEventType 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("transient"):
+        case hashString("continuous"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,88 @@
+///
+/// HapticImpactStyle.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::tickle {
+
+  /**
+   * An enum which can be represented as a JavaScript union (HapticImpactStyle).
+   */
+  enum class HapticImpactStyle {
+    RIGID      SWIFT_NAME(rigid) = 0,
+    HEAVY      SWIFT_NAME(heavy) = 1,
+    MEDIUM      SWIFT_NAME(medium) = 2,
+    LIGHT      SWIFT_NAME(light) = 3,
+    SOFT      SWIFT_NAME(soft) = 4,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::tickle
+
+namespace margelo::nitro {
+
+  // C++ HapticImpactStyle <> JS HapticImpactStyle (union)
+  template <>
+  struct JSIConverter<margelo::nitro::tickle::HapticImpactStyle> final {
+    static inline margelo::nitro::tickle::HapticImpactStyle 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("rigid"): return margelo::nitro::tickle::HapticImpactStyle::RIGID;
+        case hashString("heavy"): return margelo::nitro::tickle::HapticImpactStyle::HEAVY;
+        case hashString("medium"): return margelo::nitro::tickle::HapticImpactStyle::MEDIUM;
+        case hashString("light"): return margelo::nitro::tickle::HapticImpactStyle::LIGHT;
+        case hashString("soft"): return margelo::nitro::tickle::HapticImpactStyle::SOFT;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum HapticImpactStyle - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::tickle::HapticImpactStyle arg) {
+      switch (arg) {
+        case margelo::nitro::tickle::HapticImpactStyle::RIGID: return JSIConverter<std::string>::toJSI(runtime, "rigid");
+        case margelo::nitro::tickle::HapticImpactStyle::HEAVY: return JSIConverter<std::string>::toJSI(runtime, "heavy");
+        case margelo::nitro::tickle::HapticImpactStyle::MEDIUM: return JSIConverter<std::string>::toJSI(runtime, "medium");
+        case margelo::nitro::tickle::HapticImpactStyle::LIGHT: return JSIConverter<std::string>::toJSI(runtime, "light");
+        case margelo::nitro::tickle::HapticImpactStyle::SOFT: return JSIConverter<std::string>::toJSI(runtime, "soft");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert HapticImpactStyle 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("rigid"):
+        case hashString("heavy"):
+        case hashString("medium"):
+        case hashString("light"):
+        case hashString("soft"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// HapticNotificationType.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::tickle {
+
+  /**
+   * An enum which can be represented as a JavaScript union (HapticNotificationType).
+   */
+  enum class HapticNotificationType {
+    ERROR      SWIFT_NAME(error) = 0,
+    SUCCESS      SWIFT_NAME(success) = 1,
+    WARNING      SWIFT_NAME(warning) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::tickle
+
+namespace margelo::nitro {
+
+  // C++ HapticNotificationType <> JS HapticNotificationType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::tickle::HapticNotificationType> final {
+    static inline margelo::nitro::tickle::HapticNotificationType 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("error"): return margelo::nitro::tickle::HapticNotificationType::ERROR;
+        case hashString("success"): return margelo::nitro::tickle::HapticNotificationType::SUCCESS;
+        case hashString("warning"): return margelo::nitro::tickle::HapticNotificationType::WARNING;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum HapticNotificationType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::tickle::HapticNotificationType arg) {
+      switch (arg) {
+        case margelo::nitro::tickle::HapticNotificationType::ERROR: return JSIConverter<std::string>::toJSI(runtime, "error");
+        case margelo::nitro::tickle::HapticNotificationType::SUCCESS: return JSIConverter<std::string>::toJSI(runtime, "success");
+        case margelo::nitro::tickle::HapticNotificationType::WARNING: return JSIConverter<std::string>::toJSI(runtime, "warning");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert HapticNotificationType 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("error"):
+        case hashString("success"):
+        case hashString("warning"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,76 @@
+///
+/// HapticParameterType.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::tickle {
+
+  /**
+   * An enum which can be represented as a JavaScript union (HapticParameterType).
+   */
+  enum class HapticParameterType {
+    INTENSITY      SWIFT_NAME(intensity) = 0,
+    SHARPNESS      SWIFT_NAME(sharpness) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::tickle
+
+namespace margelo::nitro {
+
+  // C++ HapticParameterType <> JS HapticParameterType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::tickle::HapticParameterType> final {
+    static inline margelo::nitro::tickle::HapticParameterType 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("intensity"): return margelo::nitro::tickle::HapticParameterType::INTENSITY;
+        case hashString("sharpness"): return margelo::nitro::tickle::HapticParameterType::SHARPNESS;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum HapticParameterType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::tickle::HapticParameterType arg) {
+      switch (arg) {
+        case margelo::nitro::tickle::HapticParameterType::INTENSITY: return JSIConverter<std::string>::toJSI(runtime, "intensity");
+        case margelo::nitro::tickle::HapticParameterType::SHARPNESS: return JSIConverter<std::string>::toJSI(runtime, "sharpness");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert HapticParameterType 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("intensity"):
+        case hashString("sharpness"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,34 @@
+///
+/// HybridTickleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridTickleSpec.hpp"
+
+namespace margelo::nitro::tickle {
+
+  void HybridTickleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("startHaptic", &HybridTickleSpec::startHaptic);
+      prototype.registerHybridMethod("stopAllHaptics", &HybridTickleSpec::stopAllHaptics);
+      prototype.registerHybridMethod("initializeEngine", &HybridTickleSpec::initializeEngine);
+      prototype.registerHybridMethod("destroyEngine", &HybridTickleSpec::destroyEngine);
+      prototype.registerHybridMethod("createContinuousPlayer", &HybridTickleSpec::createContinuousPlayer);
+      prototype.registerHybridMethod("startContinuousPlayer", &HybridTickleSpec::startContinuousPlayer);
+      prototype.registerHybridMethod("updateContinuousPlayer", &HybridTickleSpec::updateContinuousPlayer);
+      prototype.registerHybridMethod("stopContinuousPlayer", &HybridTickleSpec::stopContinuousPlayer);
+      prototype.registerHybridMethod("destroyContinuousPlayer", &HybridTickleSpec::destroyContinuousPlayer);
+      prototype.registerHybridMethod("setHapticsEnabled", &HybridTickleSpec::setHapticsEnabled);
+      prototype.registerHybridMethod("getHapticsEnabled", &HybridTickleSpec::getHapticsEnabled);
+      prototype.registerHybridMethod("triggerImpact", &HybridTickleSpec::triggerImpact);
+      prototype.registerHybridMethod("triggerNotification", &HybridTickleSpec::triggerNotification);
+      prototype.registerHybridMethod("triggerSelection", &HybridTickleSpec::triggerSelection);
+    });
+  }
+
+} // namespace margelo::nitro::tickle