@onekeyfe/react-native-segment-slider 3.0.40

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,11 @@
+import { type ViewProps } from 'react-native';
+import type { SegmentSliderMethods, SegmentSliderProps } from './SegmentSlider.nitro';
+export type { SegmentSliderMethods, SegmentSliderProps };
+/**
+ * Thin wrapper so consumers pass plain functions. Nitro view callbacks must be
+ * wrapped with `callback(...)` to cross the JSI boundary; we encapsulate that
+ * here behind refs so the underlying functions stay stable across re-renders
+ * (otherwise every parent render would re-create the native callback).
+ */
+export declare function SegmentSliderView({ onChange, onSlideStart, onSlideComplete, ...props }: SegmentSliderProps & ViewProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAG9C,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAI/B,YAAY,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,CAAC;AAOzD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,YAAY,EACZ,eAAe,EACf,GAAG,KAAK,EACT,EAAE,kBAAkB,GAAG,SAAS,2CA4BhC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["segmentslider"],
+  "ios": {
+    "iosModuleName": "SegmentSlider"
+  },
+  "android": {
+    "androidNamespace": ["segmentslider"],
+    "androidCxxLibName": "segmentslider"
+  },
+  "autolinking": {
+    "SegmentSlider": {
+      "swift": "HybridSegmentSlider",
+      "kotlin": "HybridSegmentSlider"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

package/nitrogen/generated/android/c++/JFunc_void.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::segmentslider {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `() -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void: public jni::JavaClass<JFunc_void> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/segmentslider/Func_void;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void` instance holds through JNI.
+     */
+    void invoke() const {
+      static const auto method = javaClassStatic()->getMethod<void()>("invoke");
+      method(self());
+    }
+  };
+
+  /**
+   * An implementation of Func_void that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_cxx final: public jni::HybridClass<JFunc_void_cxx, JFunc_void> {
+  public:
+    static jni::local_ref<JFunc_void::javaobject> fromCpp(const std::function<void()>& func) {
+      return JFunc_void_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_cxx` instance holds.
+     */
+    void invoke_cxx() {
+      _func();
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void()>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/segmentslider/Func_void_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_cxx(const std::function<void()>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void()> _func;
+  };
+
+} // namespace margelo::nitro::segmentslider

package/nitrogen/generated/android/c++/JFunc_void_double.hpp

@@ -0,0 +1,75 @@
+///
+/// JFunc_void_double.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::segmentslider {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(value: Double) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_double: public jni::JavaClass<JFunc_void_double> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/segmentslider/Func_void_double;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_double` instance holds through JNI.
+     */
+    void invoke(double value) const {
+      static const auto method = javaClassStatic()->getMethod<void(double /* value */)>("invoke");
+      method(self(), value);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_double that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_double_cxx final: public jni::HybridClass<JFunc_void_double_cxx, JFunc_void_double> {
+  public:
+    static jni::local_ref<JFunc_void_double::javaobject> fromCpp(const std::function<void(double /* value */)>& func) {
+      return JFunc_void_double_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_double_cxx` instance holds.
+     */
+    void invoke_cxx(double value) {
+      _func(value);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(double /* value */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/segmentslider/Func_void_double_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_double_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_double_cxx(const std::function<void(double /* value */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(double /* value */)> _func;
+  };
+
+} // namespace margelo::nitro::segmentslider

package/nitrogen/generated/android/c++/JHybridSegmentSliderSpec.cpp

@@ -0,0 +1,265 @@
+///
+/// JHybridSegmentSliderSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridSegmentSliderSpec.hpp"
+
+
+
+#include <string>
+#include <functional>
+#include <optional>
+#include "JFunc_void_double.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JFunc_void.hpp"
+
+namespace margelo::nitro::segmentslider {
+
+  jni::local_ref<JHybridSegmentSliderSpec::jhybriddata> JHybridSegmentSliderSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridSegmentSliderSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridSegmentSliderSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridSegmentSliderSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridSegmentSliderSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridSegmentSliderSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  double JHybridSegmentSliderSpec::getValue() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getValue");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setValue(double value) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* value */)>("setValue");
+    method(_javaPart, value);
+  }
+  double JHybridSegmentSliderSpec::getMin() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMin");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setMin(double min) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* min */)>("setMin");
+    method(_javaPart, min);
+  }
+  double JHybridSegmentSliderSpec::getMax() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getMax");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setMax(double max) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* max */)>("setMax");
+    method(_javaPart, max);
+  }
+  double JHybridSegmentSliderSpec::getSegments() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSegments");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setSegments(double segments) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* segments */)>("setSegments");
+    method(_javaPart, segments);
+  }
+  double JHybridSegmentSliderSpec::getSliderHeight() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSliderHeight");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setSliderHeight(double sliderHeight) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* sliderHeight */)>("setSliderHeight");
+    method(_javaPart, sliderHeight);
+  }
+  bool JHybridSegmentSliderSpec::getDisabled() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getDisabled");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridSegmentSliderSpec::setDisabled(bool disabled) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* disabled */)>("setDisabled");
+    method(_javaPart, disabled);
+  }
+  bool JHybridSegmentSliderSpec::getShowBubble() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getShowBubble");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridSegmentSliderSpec::setShowBubble(bool showBubble) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* showBubble */)>("setShowBubble");
+    method(_javaPart, showBubble);
+  }
+  bool JHybridSegmentSliderSpec::getCenterOrigin() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getCenterOrigin");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  void JHybridSegmentSliderSpec::setCenterOrigin(bool centerOrigin) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* centerOrigin */)>("setCenterOrigin");
+    method(_javaPart, centerOrigin);
+  }
+  double JHybridSegmentSliderSpec::getEpoch() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getEpoch");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridSegmentSliderSpec::setEpoch(double epoch) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* epoch */)>("setEpoch");
+    method(_javaPart, epoch);
+  }
+  std::string JHybridSegmentSliderSpec::getFillColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getFillColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setFillColor(const std::string& fillColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* fillColor */)>("setFillColor");
+    method(_javaPart, jni::make_jstring(fillColor));
+  }
+  std::string JHybridSegmentSliderSpec::getTrackColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getTrackColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setTrackColor(const std::string& trackColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* trackColor */)>("setTrackColor");
+    method(_javaPart, jni::make_jstring(trackColor));
+  }
+  std::string JHybridSegmentSliderSpec::getThumbColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getThumbColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setThumbColor(const std::string& thumbColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* thumbColor */)>("setThumbColor");
+    method(_javaPart, jni::make_jstring(thumbColor));
+  }
+  std::string JHybridSegmentSliderSpec::getThumbBorderColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getThumbBorderColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setThumbBorderColor(const std::string& thumbBorderColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* thumbBorderColor */)>("setThumbBorderColor");
+    method(_javaPart, jni::make_jstring(thumbBorderColor));
+  }
+  std::string JHybridSegmentSliderSpec::getMarkActiveColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getMarkActiveColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setMarkActiveColor(const std::string& markActiveColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* markActiveColor */)>("setMarkActiveColor");
+    method(_javaPart, jni::make_jstring(markActiveColor));
+  }
+  std::string JHybridSegmentSliderSpec::getMarkInactiveColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getMarkInactiveColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setMarkInactiveColor(const std::string& markInactiveColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* markInactiveColor */)>("setMarkInactiveColor");
+    method(_javaPart, jni::make_jstring(markInactiveColor));
+  }
+  std::string JHybridSegmentSliderSpec::getMarkBorderColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getMarkBorderColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setMarkBorderColor(const std::string& markBorderColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* markBorderColor */)>("setMarkBorderColor");
+    method(_javaPart, jni::make_jstring(markBorderColor));
+  }
+  std::string JHybridSegmentSliderSpec::getBubbleColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getBubbleColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setBubbleColor(const std::string& bubbleColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* bubbleColor */)>("setBubbleColor");
+    method(_javaPart, jni::make_jstring(bubbleColor));
+  }
+  std::string JHybridSegmentSliderSpec::getBubbleTextColor() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getBubbleTextColor");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  void JHybridSegmentSliderSpec::setBubbleTextColor(const std::string& bubbleTextColor) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* bubbleTextColor */)>("setBubbleTextColor");
+    method(_javaPart, jni::make_jstring(bubbleTextColor));
+  }
+  std::optional<std::function<void(double /* value */)>> JHybridSegmentSliderSpec::getOnChange() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::javaobject>()>("getOnChange_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(double /* value */)> {
+      if (__result->isInstanceOf(JFunc_void_double_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_double_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_double, void(double)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridSegmentSliderSpec::setOnChange(const std::optional<std::function<void(double /* value */)>>& onChange) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double::javaobject> /* onChange */)>("setOnChange_cxx");
+    method(_javaPart, onChange.has_value() ? JFunc_void_double_cxx::fromCpp(onChange.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridSegmentSliderSpec::getOnSlideStart() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnSlideStart_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridSegmentSliderSpec::setOnSlideStart(const std::optional<std::function<void()>>& onSlideStart) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onSlideStart */)>("setOnSlideStart_cxx");
+    method(_javaPart, onSlideStart.has_value() ? JFunc_void_cxx::fromCpp(onSlideStart.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridSegmentSliderSpec::getOnSlideComplete() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnSlideComplete_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridSegmentSliderSpec::setOnSlideComplete(const std::optional<std::function<void()>>& onSlideComplete) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onSlideComplete */)>("setOnSlideComplete_cxx");
+    method(_javaPart, onSlideComplete.has_value() ? JFunc_void_cxx::fromCpp(onSlideComplete.value()) : nullptr);
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::segmentslider

package/nitrogen/generated/android/c++/JHybridSegmentSliderSpec.hpp

@@ -0,0 +1,106 @@
+///
+/// HybridSegmentSliderSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridSegmentSliderSpec.hpp"
+
+
+
+
+namespace margelo::nitro::segmentslider {
+
+  using namespace facebook;
+
+  class JHybridSegmentSliderSpec: public jni::HybridClass<JHybridSegmentSliderSpec, JHybridObject>,
+                                  public virtual HybridSegmentSliderSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/segmentslider/HybridSegmentSliderSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridSegmentSliderSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridSegmentSliderSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridSegmentSliderSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridSegmentSliderSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    double getValue() override;
+    void setValue(double value) override;
+    double getMin() override;
+    void setMin(double min) override;
+    double getMax() override;
+    void setMax(double max) override;
+    double getSegments() override;
+    void setSegments(double segments) override;
+    double getSliderHeight() override;
+    void setSliderHeight(double sliderHeight) override;
+    bool getDisabled() override;
+    void setDisabled(bool disabled) override;
+    bool getShowBubble() override;
+    void setShowBubble(bool showBubble) override;
+    bool getCenterOrigin() override;
+    void setCenterOrigin(bool centerOrigin) override;
+    double getEpoch() override;
+    void setEpoch(double epoch) override;
+    std::string getFillColor() override;
+    void setFillColor(const std::string& fillColor) override;
+    std::string getTrackColor() override;
+    void setTrackColor(const std::string& trackColor) override;
+    std::string getThumbColor() override;
+    void setThumbColor(const std::string& thumbColor) override;
+    std::string getThumbBorderColor() override;
+    void setThumbBorderColor(const std::string& thumbBorderColor) override;
+    std::string getMarkActiveColor() override;
+    void setMarkActiveColor(const std::string& markActiveColor) override;
+    std::string getMarkInactiveColor() override;
+    void setMarkInactiveColor(const std::string& markInactiveColor) override;
+    std::string getMarkBorderColor() override;
+    void setMarkBorderColor(const std::string& markBorderColor) override;
+    std::string getBubbleColor() override;
+    void setBubbleColor(const std::string& bubbleColor) override;
+    std::string getBubbleTextColor() override;
+    void setBubbleTextColor(const std::string& bubbleTextColor) override;
+    std::optional<std::function<void(double /* value */)>> getOnChange() override;
+    void setOnChange(const std::optional<std::function<void(double /* value */)>>& onChange) override;
+    std::optional<std::function<void()>> getOnSlideStart() override;
+    void setOnSlideStart(const std::optional<std::function<void()>>& onSlideStart) override;
+    std::optional<std::function<void()>> getOnSlideComplete() override;
+    void setOnSlideComplete(const std::optional<std::function<void()>>& onSlideComplete) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridSegmentSliderSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::segmentslider