react-native-nitro-geolocation 0.0.1 → 0.1.0

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

@@ -0,0 +1,91 @@
+///
+/// GeolocationOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+
+
+#include <optional>
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * A struct which can be represented as a JavaScript object (GeolocationOptions).
+   */
+  struct GeolocationOptions {
+  public:
+    std::optional<double> timeout     SWIFT_PRIVATE;
+    std::optional<double> maximumAge     SWIFT_PRIVATE;
+    std::optional<bool> enableHighAccuracy     SWIFT_PRIVATE;
+    std::optional<double> interval     SWIFT_PRIVATE;
+    std::optional<double> fastestInterval     SWIFT_PRIVATE;
+    std::optional<double> distanceFilter     SWIFT_PRIVATE;
+    std::optional<bool> useSignificantChanges     SWIFT_PRIVATE;
+
+  public:
+    GeolocationOptions() = default;
+    explicit GeolocationOptions(std::optional<double> timeout, std::optional<double> maximumAge, std::optional<bool> enableHighAccuracy, std::optional<double> interval, std::optional<double> fastestInterval, std::optional<double> distanceFilter, std::optional<bool> useSignificantChanges): timeout(timeout), maximumAge(maximumAge), enableHighAccuracy(enableHighAccuracy), interval(interval), fastestInterval(fastestInterval), distanceFilter(distanceFilter), useSignificantChanges(useSignificantChanges) {}
+  };
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ GeolocationOptions <> JS GeolocationOptions (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::GeolocationOptions> final {
+    static inline margelo::nitro::nitrogeolocation::GeolocationOptions fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrogeolocation::GeolocationOptions(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "timeout")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "maximumAge")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "enableHighAccuracy")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "interval")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "fastestInterval")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "distanceFilter")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "useSignificantChanges"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::GeolocationOptions& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "timeout", JSIConverter<std::optional<double>>::toJSI(runtime, arg.timeout));
+      obj.setProperty(runtime, "maximumAge", JSIConverter<std::optional<double>>::toJSI(runtime, arg.maximumAge));
+      obj.setProperty(runtime, "enableHighAccuracy", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.enableHighAccuracy));
+      obj.setProperty(runtime, "interval", JSIConverter<std::optional<double>>::toJSI(runtime, arg.interval));
+      obj.setProperty(runtime, "fastestInterval", JSIConverter<std::optional<double>>::toJSI(runtime, arg.fastestInterval));
+      obj.setProperty(runtime, "distanceFilter", JSIConverter<std::optional<double>>::toJSI(runtime, arg.distanceFilter));
+      obj.setProperty(runtime, "useSignificantChanges", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.useSignificantChanges));
+      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 (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "timeout"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "maximumAge"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "enableHighAccuracy"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "interval"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "fastestInterval"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "distanceFilter"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "useSignificantChanges"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,72 @@
+///
+/// GeolocationResponse.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+// Forward declaration of `GeolocationCoordinates` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationCoordinates; }
+
+#include "GeolocationCoordinates.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * A struct which can be represented as a JavaScript object (GeolocationResponse).
+   */
+  struct GeolocationResponse {
+  public:
+    GeolocationCoordinates coords     SWIFT_PRIVATE;
+    double timestamp     SWIFT_PRIVATE;
+
+  public:
+    GeolocationResponse() = default;
+    explicit GeolocationResponse(GeolocationCoordinates coords, double timestamp): coords(coords), timestamp(timestamp) {}
+  };
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ GeolocationResponse <> JS GeolocationResponse (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::GeolocationResponse> final {
+    static inline margelo::nitro::nitrogeolocation::GeolocationResponse fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrogeolocation::GeolocationResponse(
+        JSIConverter<margelo::nitro::nitrogeolocation::GeolocationCoordinates>::fromJSI(runtime, obj.getProperty(runtime, "coords")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "timestamp"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::GeolocationResponse& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "coords", JSIConverter<margelo::nitro::nitrogeolocation::GeolocationCoordinates>::toJSI(runtime, arg.coords));
+      obj.setProperty(runtime, "timestamp", JSIConverter<double>::toJSI(runtime, arg.timestamp));
+      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 (!JSIConverter<margelo::nitro::nitrogeolocation::GeolocationCoordinates>::canConvert(runtime, obj.getProperty(runtime, "coords"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "timestamp"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,26 @@
+///
+/// HybridNitroGeolocationSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroGeolocationSpec.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  void HybridNitroGeolocationSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("setRNConfiguration", &HybridNitroGeolocationSpec::setRNConfiguration);
+      prototype.registerHybridMethod("requestAuthorization", &HybridNitroGeolocationSpec::requestAuthorization);
+      prototype.registerHybridMethod("getCurrentPosition", &HybridNitroGeolocationSpec::getCurrentPosition);
+      prototype.registerHybridMethod("watchPosition", &HybridNitroGeolocationSpec::watchPosition);
+      prototype.registerHybridMethod("clearWatch", &HybridNitroGeolocationSpec::clearWatch);
+      prototype.registerHybridMethod("stopObserving", &HybridNitroGeolocationSpec::stopObserving);
+    });
+  }
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,79 @@
+///
+/// HybridNitroGeolocationSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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 `RNConfigurationInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct RNConfigurationInternal; }
+// Forward declaration of `GeolocationError` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationError; }
+// Forward declaration of `GeolocationResponse` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationResponse; }
+// Forward declaration of `GeolocationOptions` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { struct GeolocationOptions; }
+
+#include "RNConfigurationInternal.hpp"
+#include <functional>
+#include <optional>
+#include "GeolocationError.hpp"
+#include "GeolocationResponse.hpp"
+#include "GeolocationOptions.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `NitroGeolocation`
+   * Inherit this class to create instances of `HybridNitroGeolocationSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridNitroGeolocation: public HybridNitroGeolocationSpec {
+   * public:
+   *   HybridNitroGeolocation(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridNitroGeolocationSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridNitroGeolocationSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridNitroGeolocationSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void setRNConfiguration(const RNConfigurationInternal& config) = 0;
+      virtual void requestAuthorization(const std::optional<std::function<void()>>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error) = 0;
+      virtual void getCurrentPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) = 0;
+      virtual double watchPosition(const std::function<void(const GeolocationResponse& /* position */)>& success, const std::optional<std::function<void(const GeolocationError& /* error */)>>& error, const std::optional<GeolocationOptions>& options) = 0;
+      virtual void clearWatch(double watchId) = 0;
+      virtual void stopObserving() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "NitroGeolocation";
+  };
+
+} // namespace margelo::nitro::nitrogeolocation

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

@@ -0,0 +1,80 @@
+///
+/// LocationProviderInternal.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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::nitrogeolocation {
+
+  /**
+   * An enum which can be represented as a JavaScript union (LocationProviderInternal).
+   */
+  enum class LocationProviderInternal {
+    AUTO      SWIFT_NAME(auto) = 0,
+    PLAYSERVICES      SWIFT_NAME(playservices) = 1,
+    ANDROID_PLATFORM      SWIFT_NAME(androidPlatform) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ LocationProviderInternal <> JS LocationProviderInternal (union)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::LocationProviderInternal> final {
+    static inline margelo::nitro::nitrogeolocation::LocationProviderInternal 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("auto"): return margelo::nitro::nitrogeolocation::LocationProviderInternal::AUTO;
+        case hashString("playServices"): return margelo::nitro::nitrogeolocation::LocationProviderInternal::PLAYSERVICES;
+        case hashString("android_platform"): return margelo::nitro::nitrogeolocation::LocationProviderInternal::ANDROID_PLATFORM;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum LocationProviderInternal - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::nitrogeolocation::LocationProviderInternal arg) {
+      switch (arg) {
+        case margelo::nitro::nitrogeolocation::LocationProviderInternal::AUTO: return JSIConverter<std::string>::toJSI(runtime, "auto");
+        case margelo::nitro::nitrogeolocation::LocationProviderInternal::PLAYSERVICES: return JSIConverter<std::string>::toJSI(runtime, "playServices");
+        case margelo::nitro::nitrogeolocation::LocationProviderInternal::ANDROID_PLATFORM: return JSIConverter<std::string>::toJSI(runtime, "android_platform");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert LocationProviderInternal 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("auto"):
+        case hashString("playServices"):
+        case hashString("android_platform"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,84 @@
+///
+/// RNConfigurationInternal.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+// Forward declaration of `AuthorizationLevelInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class AuthorizationLevelInternal; }
+// Forward declaration of `LocationProviderInternal` to properly resolve imports.
+namespace margelo::nitro::nitrogeolocation { enum class LocationProviderInternal; }
+
+#include "AuthorizationLevelInternal.hpp"
+#include <optional>
+#include "LocationProviderInternal.hpp"
+
+namespace margelo::nitro::nitrogeolocation {
+
+  /**
+   * A struct which can be represented as a JavaScript object (RNConfigurationInternal).
+   */
+  struct RNConfigurationInternal {
+  public:
+    bool skipPermissionRequests     SWIFT_PRIVATE;
+    std::optional<AuthorizationLevelInternal> authorizationLevel     SWIFT_PRIVATE;
+    std::optional<bool> enableBackgroundLocationUpdates     SWIFT_PRIVATE;
+    std::optional<LocationProviderInternal> locationProvider     SWIFT_PRIVATE;
+
+  public:
+    RNConfigurationInternal() = default;
+    explicit RNConfigurationInternal(bool skipPermissionRequests, std::optional<AuthorizationLevelInternal> authorizationLevel, std::optional<bool> enableBackgroundLocationUpdates, std::optional<LocationProviderInternal> locationProvider): skipPermissionRequests(skipPermissionRequests), authorizationLevel(authorizationLevel), enableBackgroundLocationUpdates(enableBackgroundLocationUpdates), locationProvider(locationProvider) {}
+  };
+
+} // namespace margelo::nitro::nitrogeolocation
+
+namespace margelo::nitro {
+
+  // C++ RNConfigurationInternal <> JS RNConfigurationInternal (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrogeolocation::RNConfigurationInternal> final {
+    static inline margelo::nitro::nitrogeolocation::RNConfigurationInternal fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrogeolocation::RNConfigurationInternal(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "skipPermissionRequests")),
+        JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::fromJSI(runtime, obj.getProperty(runtime, "authorizationLevel")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "enableBackgroundLocationUpdates")),
+        JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::fromJSI(runtime, obj.getProperty(runtime, "locationProvider"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrogeolocation::RNConfigurationInternal& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "skipPermissionRequests", JSIConverter<bool>::toJSI(runtime, arg.skipPermissionRequests));
+      obj.setProperty(runtime, "authorizationLevel", JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::toJSI(runtime, arg.authorizationLevel));
+      obj.setProperty(runtime, "enableBackgroundLocationUpdates", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.enableBackgroundLocationUpdates));
+      obj.setProperty(runtime, "locationProvider", JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::toJSI(runtime, arg.locationProvider));
+      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 (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "skipPermissionRequests"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitrogeolocation::AuthorizationLevelInternal>>::canConvert(runtime, obj.getProperty(runtime, "authorizationLevel"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "enableBackgroundLocationUpdates"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::nitrogeolocation::LocationProviderInternal>>::canConvert(runtime, obj.getProperty(runtime, "locationProvider"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -1,36 +1,60 @@
 {
   "name": "react-native-nitro-geolocation",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "⚡🚀Blazing-fast geolocation for React Native powered by Nitro Modules",
   "main": "src/index",
+  "source": "src/index",
   "codegenConfig": {
     "name": "NitroGeolocationSpec",
     "type": "modules",
     "jsSrcsDir": "src"
   },
+  "scripts": {
+    "typecheck": "tsc --noEmit"
+  },
   "author": "jingjing2222",
   "license": "MIT",
-  "homepage": "#readme",
+  "homepage": "https://react-native-nitro-geolocation.pages.dev",
   "repository": "https://github.com/jingjing2222/react-native-nitro-geolocation",
   "files": [
     "src",
-    "android",
-    "ios",
-    "nitro.json",
-    "NitroGeolocation.podspec",
-    "turbo.json",
-    "LICENSE"
+    "react-native.config.js",
+    "lib",
+    "nitrogen",
+    "cpp",
+    "android/build.gradle",
+    "android/fix-prefab.gradle",
+    "android/gradle.properties",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios/**/*.h",
+    "ios/**/*.m",
+    "ios/**/*.mm",
+    "ios/**/*.cpp",
+    "ios/**/*.swift",
+    "app.plugin.js",
+    "*.podspec",
+    "README.md"
   ],
   "devDependencies": {
     "@react-native/babel-preset": "0.81.1",
+    "@tsconfig/react-native": "^3.0.7",
     "@types/react": "^19.1.0",
+    "@types/react-test-renderer": "^18.0.0",
     "react": "19.1.0",
-    "react-native": "0.81.1"
+    "react-native": "0.81.1",
+    "react-native-nitro-modules": "^0.29.7",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "react-native-nitro-modules": "*"
   },
   "create-react-native-library": {
     "languages": "kotlin-swift",
     "type": "nitro-module",
     "version": "0.54.3"
   },
-  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+  "installConfig": {
+    "hoistingLimits": "workspaces"
+  }
 }

package/src/NitroGeolocation.nitro.ts

@@ -1,6 +1,41 @@
-import type { HybridObject } from 'react-native-nitro-modules';
+import type { HybridObject } from "react-native-nitro-modules";
+import type {
+  GeolocationError,
+  GeolocationOptions,
+  GeolocationResponse
+} from "./types";
+
+// Configuration - Internal (for C++ codegen, avoiding ANDROID macro conflict)
+export type AuthorizationLevelInternal = "always" | "whenInUse" | "auto";
+export type LocationProviderInternal =
+  | "playServices"
+  | "android_platform"
+  | "auto";
+
+export interface RNConfigurationInternal {
+  skipPermissionRequests: boolean;
+  authorizationLevel?: AuthorizationLevelInternal;
+  enableBackgroundLocationUpdates?: boolean;
+  locationProvider?: LocationProviderInternal;
+}
 
 export interface NitroGeolocation
-  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
-  multiply(a: number, b: number): number;
+  extends HybridObject<{ ios: "swift"; android: "kotlin" }> {
+  setRNConfiguration(config: RNConfigurationInternal): void;
+  requestAuthorization(
+    success?: () => void,
+    error?: (error: GeolocationError) => void
+  ): void;
+  getCurrentPosition(
+    success: (position: GeolocationResponse) => void,
+    error?: (error: GeolocationError) => void,
+    options?: GeolocationOptions
+  ): void;
+  watchPosition(
+    success: (position: GeolocationResponse) => void,
+    error?: (error: GeolocationError) => void,
+    options?: GeolocationOptions
+  ): number;
+  clearWatch(watchId: number): void;
+  stopObserving(): void;
 }

package/src/NitroGeolocationModule.ts

@@ -0,0 +1,5 @@
+import { NitroModules } from "react-native-nitro-modules";
+import type { NitroGeolocation } from "./NitroGeolocation.nitro";
+
+export const NitroGeolocationHybridObject =
+  NitroModules.createHybridObject<NitroGeolocation>("NitroGeolocation");

package/src/clearWatch.ts

@@ -0,0 +1,13 @@
+import { NitroModules } from "react-native-nitro-modules";
+import type { NitroGeolocation } from "./NitroGeolocation.nitro";
+
+/**
+ * Clears a specific watch session identified by watchId.
+ *
+ * @param watchId - The ID returned by watchPosition()
+ */
+export function clearWatch(watchId: number): void {
+  const nitroGeolocation =
+    NitroModules.createHybridObject<NitroGeolocation>("NitroGeolocation");
+  nitroGeolocation.clearWatch(watchId);
+}

package/src/getCurrentPosition.ts

@@ -0,0 +1,14 @@
+import { NitroGeolocationHybridObject } from "./NitroGeolocationModule";
+import type {
+  GeolocationError,
+  GeolocationOptions,
+  GeolocationResponse
+} from "./types";
+
+export function getCurrentPosition(
+  success: (position: GeolocationResponse) => void,
+  error?: (error: GeolocationError) => void,
+  options?: GeolocationOptions
+): void {
+  NitroGeolocationHybridObject.getCurrentPosition(success, error, options);
+}

package/src/index.tsx

@@ -1,9 +1,34 @@
-import { NitroModules } from 'react-native-nitro-modules';
-import type { NitroGeolocation } from './NitroGeolocation.nitro';
+// Export methods
+export { clearWatch } from "./clearWatch";
+export { getCurrentPosition } from "./getCurrentPosition";
+export { requestAuthorization } from "./requestAuthorization";
+export { setRNConfiguration } from "./setRNConfiguration";
+export { stopObserving } from "./stopObserving";
+export { watchPosition } from "./watchPosition";
 
-const NitroGeolocationHybridObject =
-  NitroModules.createHybridObject<NitroGeolocation>('NitroGeolocation');
+// Default export for compatibility
+import { clearWatch } from "./clearWatch";
+import { getCurrentPosition } from "./getCurrentPosition";
+import { requestAuthorization } from "./requestAuthorization";
+import { setRNConfiguration } from "./setRNConfiguration";
+import { stopObserving } from "./stopObserving";
+import { watchPosition } from "./watchPosition";
 
-export function multiply(a: number, b: number): number {
-  return NitroGeolocationHybridObject.multiply(a, b);
-}
+const Geolocation = {
+  setRNConfiguration,
+  requestAuthorization,
+  getCurrentPosition,
+  watchPosition,
+  clearWatch,
+  stopObserving
+};
+
+// Export types
+export type {
+  GeolocationConfiguration,
+  GeolocationResponse,
+  GeolocationError,
+  GeolocationOptions
+} from "./types";
+
+export default Geolocation;

package/src/requestAuthorization.ts

@@ -0,0 +1,9 @@
+import { NitroGeolocationHybridObject } from "./NitroGeolocationModule";
+import type { GeolocationError } from "./types";
+
+export function requestAuthorization(
+  success?: () => void,
+  error?: (error: GeolocationError) => void
+): void {
+  NitroGeolocationHybridObject.requestAuthorization(success, error);
+}