@movexgeo/react-native-movex 0.1.0

package/lib/typescript/types.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Per-surface base URLs, or a named preset resolved by the native SDK.
+ *
+ * ## Preset form (recommended)
+ *
+ * Pass `{ preset: 'production' }` to use the native SDK's built-in
+ * production endpoint configuration (`https://movex.citymall.live`).
+ * The URL constants live in the native SDK — TypeScript is intentionally
+ * not the source of truth.
+ *
+ *   `'production'` — `https://movex.citymall.live`, pinning disabled
+ *                    until real SPKI hashes are computed post-deploy.
+ *   `'localDev'`   — emulator/simulator loopback defaults
+ *                    (Android: `http://10.0.2.2:809*`,
+ *                     iOS: `http://localhost:809*`).
+ *
+ * ## Explicit form
+ *
+ * Omit `preset` and supply individual URL strings. All three fields
+ * default to the loopback when absent.
+ *
+ *   `{ ingest: 'https://…', auth: 'https://…', events: 'https://…' }`
+ *
+ * ## Mixed form
+ *
+ * Combine `preset` with explicit overrides — the explicit values win.
+ * Useful for e.g. pointing `events` at a staging service while keeping
+ * everything else on production:
+ *
+ *   `{ preset: 'production', events: 'https://staging.events.example' }`
+ *
+ * ## Cert pinning
+ *
+ * `pinnedHosts` maps an HTTPS hostname to a list of `sha256/<base64>`
+ * SubjectPublicKeyInfo pins. When non-empty, every TLS handshake
+ * against a pinned host is checked before the request body is sent.
+ * See the native SDK docs for the openssl recipe used to compute pins.
+ */
+export interface Endpoints {
+    /**
+     * Named endpoint preset resolved by the native SDK. When set, the
+     * bridge calls the corresponding native factory method
+     * (`Endpoints.production()` / `Endpoints()`) instead of constructing
+     * an `Endpoints` object from explicit URLs. Explicit URL fields and
+     * `pinnedHosts`, when also present, override the preset values.
+     */
+    preset?: 'production' | 'localDev';
+    ingest?: string;
+    auth?: string;
+    events?: string;
+    pinnedHosts?: {
+        [host: string]: string[];
+    };
+}
+/**
+ * Battery / accuracy preset. Matches the native SDKs.
+ *
+ *   efficient   - low power, sig-changes only (~500m granularity, runs
+ *                 in background once Always is granted)
+ *   responsive  - balanced, ~50m updates while foreground; sig-changes
+ *                 in background. Default for most apps.
+ *   continuous  - HIGH accuracy, foreground-only unless host app has
+ *                 active foreground location entitlement / Live Activity.
+ */
+export type Preset = 'efficient' | 'responsive' | 'continuous';
+export interface ProjectInfo {
+    project_id: string;
+    org_id: string;
+    /** 'paid' | 'shared' | 'local' */
+    tier: 'paid' | 'shared' | 'local';
+    key_type: string;
+    scopes: string[];
+    rate_limit_per_min?: number;
+    features?: string[];
+    data_region?: string;
+}
+/**
+ * A single on-device location fix. Delivered via `MovexGeo.onLocations`
+ * for all tier types. For LOCAL-tier projects this is the **only** way
+ * to receive location data — no server traffic is produced.
+ *
+ * Cross-platform shape shared by Android, iOS, and the RN bridge.
+ */
+export interface LocationFix {
+    lat: number;
+    lng: number;
+    /** Horizontal accuracy radius in metres. */
+    accuracy_m: number;
+    /** RFC3339 / ISO-8601 UTC timestamp of the fix. */
+    ts_event: string;
+    /** Ground speed in m/s. Absent when the OS did not report speed. */
+    speed_mps?: number;
+    /** Bearing in degrees [0, 360). Absent when unavailable. */
+    heading_deg?: number;
+    /** Provider / fused source identifier: 'gps' | 'fused' | 'replay'. */
+    source: string;
+}
+export interface NearbyFence {
+    id: string;
+    lat: number;
+    lng: number;
+    radius_m: number;
+}
+export interface TrackResponse {
+    accepted: boolean;
+    nearby_fences?: NearbyFence[];
+}
+/**
+ * Event row matching the geofence + trip union the events-api returns.
+ * `event_type` discriminates: `user.entered_geofence`,
+ * `user.exited_geofence`, `trip.started`, `trip.approaching`,
+ * `trip.arrived`, `trip.completed`, `trip.cancelled`, `trip.expired`.
+ */
+export interface MovexGeoEvent {
+    event_id: string;
+    event_type: string;
+    project_id: string;
+    device_id?: string;
+    user_external_id?: string;
+    geofence_id?: string;
+    lat?: number;
+    lng?: number;
+    accuracy_m?: number;
+    confidence?: number;
+    trip_id?: string;
+    mode?: string;
+    status?: string;
+    ts_event: string;
+    ts_received: string;
+}
+/**
+ * Errors raised by the bridge. The `code` field is the same
+ * vocabulary the backend uses (`invalid_key`, `key_revoked`,
+ * `project_suspended`, `bad_request`, etc.). Use it for branchy
+ * error handling rather than string-matching `message`.
+ */
+export interface MovexGeoErrorPayload {
+    code: string;
+    message: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,WAAW,SAAS;IACxB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,YAAY,GAAG,UAAU,CAAC;IACnC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;KAAE,CAAC;CAC5C;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,MAAM,GAAG,WAAW,GAAG,YAAY,GAAG,YAAY,CAAC;AAE/D,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,4CAA4C;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sEAAsE;IACtE,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,OAAO,CAAC;IAClB,aAAa,CAAC,EAAE,WAAW,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@movexgeo/react-native-movex",
+  "version": "0.1.0",
+  "description": "React Native bridge for movex.geo. Wraps the native Android (Kotlin) + iOS (Swift) SDKs as a TurboModule with TypeScript types.",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "*.podspec",
+    "!**/__tests__",
+    "!**/__mocks__"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "bob build",
+    "prepack": "bob build"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "geofencing",
+    "location",
+    "movex.geo"
+  ],
+  "repository": "https://github.com/city-mall/movex-geo.git",
+  "author": "CityMall <noreply@citymall.live>",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "peerDependencies": {
+    "react": ">=18.2.0",
+    "react-native": ">=0.73.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.0",
+    "react": "^19.2.3",
+    "react-native": "^0.85.3",
+    "react-native-builder-bob": "^0.30.0",
+    "typescript": "^5.8.3"
+  },
+  "codegenConfig": {
+    "name": "MovexGeoSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "movex.geo.rn"
+    }
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      "typescript"
+    ]
+  },
+  "packageManager": "yarn@4.7.0"
+}

package/src/MovexGeo.ts

@@ -0,0 +1,317 @@
+// Public TS wrapper around the TurboModule. Provides type-safe
+// methods + the NativeEventEmitter plumbing for `onEvents`.
+
+import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+import NativeMovexGeo from './NativeMovexGeo';
+import type {
+  Endpoints,
+  LocationFix,
+  MovexGeoEvent,
+  Preset,
+  ProjectInfo,
+  TrackResponse,
+} from './types';
+
+const LINKING_ERROR =
+  `The package '@movexgeo/react-native-movex' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({
+    ios: "- you have run 'pod install'\n",
+    default: '',
+  }) +
+  '- you rebuilt the app after installing the package\n' +
+  '- you are not using Expo Go\n';
+
+// Codegen-driven access; falls back to the legacy bridge for the
+// (decreasingly common) case of an old-architecture host app.
+const MovexGeoTurbo: any =
+  NativeMovexGeo ?? NativeModules.MovexGeo;
+
+if (!MovexGeoTurbo) {
+  throw new Error(LINKING_ERROR);
+}
+
+const eventsEmitter = new NativeEventEmitter(MovexGeoTurbo as any);
+
+const EVENTS_TOPIC    = 'movex.events';
+const LOCATIONS_TOPIC = 'movex.locations';
+
+export type EventsHandler    = (events: MovexGeoEvent[]) => void;
+export type LocationsHandler = (fix: LocationFix) => void;
+
+export interface EventsSubscription {
+  /** Stop receiving events on this handler. Idempotent. */
+  remove(): void;
+}
+
+export interface LocationsSubscription {
+  /** Stop receiving location fixes on this handler. Idempotent. */
+  remove(): void;
+}
+
+/**
+ * Singleton facade. Mirrors the Android `MovexGeo` object and the
+ * iOS `MovexGeo.shared` class — same method names, same semantics.
+ *
+ * Usage:
+ *
+ *   import MovexGeo from '@movexgeo/react-native-movex';
+ *
+ *   await MovexGeo.initialize('pub_live_…');
+ *   await MovexGeo.setUserId('u_42');
+ *   const info = await MovexGeo.verify();
+ *   const sub = MovexGeo.onEvents(events => console.log(events));
+ *   ...
+ *   sub.remove();
+ *   await MovexGeo.close();
+ */
+const MovexGeo = {
+  /**
+   * Configure the SDK. No network is performed — first track / verify
+   * call surfaces an invalid key (strict-lazy auth, ADR-0007).
+   *
+   * @param publishableKey  pub_live_<base32> from the dashboard
+   * @param endpoints       optional; defaults to local-dev loopback.
+   *
+   * **For production builds**, pass `{ preset: 'production' }` — the
+   * native SDK resolves the URL and TLS configuration so TypeScript
+   * is never the source of truth for prod URLs:
+   *
+   * ```ts
+   * await MovexGeo.initialize('pub_live_…', { preset: 'production' });
+   * ```
+   *
+   * To target the local dev backend (Android emulator / iOS simulator):
+   *
+   * ```ts
+   * await MovexGeo.initialize('pub_live_…', { preset: 'localDev' });
+   * // or omit endpoints entirely — defaults to localDev
+   * await MovexGeo.initialize('pub_live_…');
+   * ```
+   */
+  initialize(publishableKey: string, endpoints?: Endpoints): Promise<void> {
+    return MovexGeoTurbo.initialize(publishableKey, endpoints ?? {});
+  },
+
+  /**
+   * Attach a stable customer-side user id. Sent on every subsequent
+   * track payload as `userId` and surfaces as `user_external_id` in
+   * downstream geofence + trip events.
+   */
+  setUserId(userId: string | null): Promise<void> {
+    return MovexGeoTurbo.setUserId(userId);
+  },
+
+  /** Stable per-install id (Keychain on iOS, EncryptedSharedPreferences on Android). */
+  getDeviceId(): Promise<string> {
+    return MovexGeoTurbo.getDeviceId();
+  },
+
+  /** Resolve the publishable key against `/v1/me`. */
+  verify(): Promise<ProjectInfo> {
+    return MovexGeoTurbo.verify() as Promise<ProjectInfo>;
+  },
+
+  /** One-shot ping. Useful for "where am I" smoke tests. */
+  trackOnce(
+    lat: number,
+    lng: number,
+    accuracyM: number = 12,
+  ): Promise<TrackResponse> {
+    return MovexGeoTurbo.trackOnce(lat, lng, accuracyM) as Promise<TrackResponse>;
+  },
+
+  /**
+   * Begin continuous tracking. Host app **must** declare the
+   * platform-appropriate location-permission Info.plist /
+   * AndroidManifest entries — see the native SDK docs.
+   */
+  startTracking(preset: Preset = 'responsive'): Promise<void> {
+    return MovexGeoTurbo.startTracking(preset);
+  },
+
+  stopTracking(): Promise<void> {
+    return MovexGeoTurbo.stopTracking();
+  },
+
+  /**
+   * Toggle a developer-mode override that lowers per-preset min-distance
+   * triggers and shortens cadences so emulator + stationary desk testing
+   * actually emits fixes (production thresholds normally require 50–200m
+   * of physical movement).
+   *
+   * **Production builds should leave this off.** Persisted natively across
+   * process restarts; call `setDevMode(false)` to clear before shipping.
+   *
+   * Currently Android-only — iOS uses CLLocationManager presets that
+   * already emit at-rest fixes, so the override is a no-op there.
+   */
+  setDevMode(enabled: boolean): Promise<void> {
+    if (typeof MovexGeoTurbo.setDevMode !== 'function') return Promise.resolve();
+    return MovexGeoTurbo.setDevMode(enabled);
+  },
+
+  /**
+   * Customise the foreground-service notification (Android only —
+   * white-label support). All fields optional; pass null to fall back
+   * to SDK defaults.
+   *
+   * `iconResName` is the drawable resource NAME inside the host app's
+   * `res/drawable/` (or `res/mipmap/`) — e.g. `"ic_stat_tracking"`. The
+   * SDK looks it up against the host package at runtime so customers
+   * never have to inject icons into the SDK.
+   *
+   * Persisted natively. Takes effect on the next `startTracking()` (or
+   * the next sticky-restart of the FGS, whichever comes first). Does
+   * NOT live-update an in-flight tracking session.
+   *
+   * iOS: no-op (background location SDKs on iOS don't post a service
+   * notification — Apple manages the system blue/grey indicator).
+   */
+  setNotificationConfig(config: {
+    title?: string | null;
+    text?: string | null;
+    channelId?: string | null;
+    channelName?: string | null;
+    iconResName?: string | null;
+  }): Promise<void> {
+    if (Platform.OS !== 'android') return Promise.resolve();
+    if (typeof MovexGeoTurbo.setNotificationConfig !== 'function') return Promise.resolve();
+    return MovexGeoTurbo.setNotificationConfig(config);
+  },
+
+  /**
+   * Restart tracking automatically when the device finishes booting
+   * (Android only). Off by default.
+   *
+   * Useful for fleet devices that reboot unattended (driver phone in
+   * cradle overnight). The host must already hold ACCESS_FINE_LOCATION
+   * — the boot receiver cannot prompt.
+   *
+   * Skipped silently for the EFFICIENT preset, which doesn't run an FGS.
+   *
+   * iOS: no-op (iOS auto-resumes background location via Significant
+   * Location Changes; no equivalent host opt-in needed).
+   */
+  setAutostartOnBoot(enabled: boolean): Promise<void> {
+    if (Platform.OS !== 'android') return Promise.resolve();
+    if (typeof MovexGeoTurbo.setAutostartOnBoot !== 'function') return Promise.resolve();
+    return MovexGeoTurbo.setAutostartOnBoot(enabled);
+  },
+
+  /**
+   * `true` if the host package is currently exempt from Doze battery
+   * optimizations (Android only). Always `true` on iOS.
+   *
+   * Note: this answers the AOSP question only. OEM-specific autostart
+   * whitelists (MIUI / ColorOS / etc) are independent and not
+   * introspectable — use [hasOemBatterySettings] / [openOemBatterySettings].
+   */
+  isIgnoringBatteryOptimizations(): Promise<boolean> {
+    if (Platform.OS !== 'android') return Promise.resolve(true);
+    if (typeof MovexGeoTurbo.isIgnoringBatteryOptimizations !== 'function') return Promise.resolve(true);
+    return MovexGeoTurbo.isIgnoringBatteryOptimizations();
+  },
+
+  /**
+   * Open the OS prompt asking the user to exempt the host app from
+   * battery optimizations. Returns `true` if a screen was launched.
+   *
+   * Per Play Store policy, the underlying intent is restricted to apps
+   * that justify continuous background execution (fleet tracking,
+   * navigation). Make sure your store listing declares why.
+   *
+   * iOS: no-op (returns false).
+   */
+  requestIgnoreBatteryOptimizations(): Promise<boolean> {
+    if (Platform.OS !== 'android') return Promise.resolve(false);
+    if (typeof MovexGeoTurbo.requestIgnoreBatteryOptimizations !== 'function') return Promise.resolve(false);
+    return MovexGeoTurbo.requestIgnoreBatteryOptimizations();
+  },
+
+  /**
+   * `true` if at least one OEM-specific autostart / power-management
+   * screen is reachable on the current device (MIUI / ColorOS / Vivo
+   * / Realme / Honor / Samsung / OnePlus / Asus). Use this to gate UI
+   * that prompts the user to whitelist the app.
+   *
+   * iOS: always `false`.
+   */
+  hasOemBatterySettings(): Promise<boolean> {
+    if (Platform.OS !== 'android') return Promise.resolve(false);
+    if (typeof MovexGeoTurbo.hasOemSettings !== 'function') return Promise.resolve(false);
+    return MovexGeoTurbo.hasOemSettings();
+  },
+
+  /**
+   * Try the OEM-specific autostart screen for the current manufacturer
+   * (with AOSP fallback to the per-app system settings). Returns
+   * `true` if a screen was launched.
+   *
+   * **Important caveat:** these intents target OEM-internal activities
+   * that can disappear in ROM updates. Always pair with a UI that
+   * tells the user what they're being shown — they may need handholding
+   * through MIUI's "Autostart" / ColorOS's "Background allowed" toggles.
+   *
+   * iOS: no-op (returns false).
+   */
+  openOemBatterySettings(): Promise<boolean> {
+    if (Platform.OS !== 'android') return Promise.resolve(false);
+    if (typeof MovexGeoTurbo.openOemSettings !== 'function') return Promise.resolve(false);
+    return MovexGeoTurbo.openOemSettings();
+  },
+
+  /**
+   * Subscribe to a 5s long-poll of `GET /v1/events`. Returns a
+   * subscription handle; call `.remove()` to stop. Only one logical
+   * subscription per app — the underlying native poller is single-
+   * instance.
+   *
+   * No-op for LOCAL-tier projects (no server events are generated).
+   */
+  onEvents(handler: EventsHandler): EventsSubscription {
+    const sub = eventsEmitter.addListener(EVENTS_TOPIC, (raw: unknown) => {
+      // Native sends one batch per poll; same shape on both platforms.
+      const events = Array.isArray(raw) ? (raw as MovexGeoEvent[]) : [];
+      handler(events);
+    });
+    return { remove: () => sub.remove() };
+  },
+
+  /**
+   * Subscribe to on-device location fixes. The handler fires for every
+   * fix the SDK produces, regardless of tier.
+   *
+   * For LOCAL-tier projects this is the **only** way to receive location
+   * data — no server traffic is produced. For PAID / SHARED projects
+   * the same fixes are also forwarded to the server; use this for a
+   * low-latency local preview.
+   *
+   * Native event topic: `'movex.locations'`.
+   */
+  onLocations(handler: LocationsHandler): LocationsSubscription {
+    const sub = eventsEmitter.addListener(LOCATIONS_TOPIC, (raw: unknown) => {
+      handler(raw as LocationFix);
+    });
+    return { remove: () => sub.remove() };
+  },
+
+  /** Number of pings sitting in the offline buffer waiting for replay. */
+  bufferedCount(): Promise<number> {
+    return MovexGeoTurbo.bufferedCount();
+  },
+
+  /**
+   * Replay the offline buffer to `POST /v1/locations`. No-op when
+   * empty. Throws on failure leaving items in the buffer for retry.
+   */
+  drainBuffer(): Promise<void> {
+    return MovexGeoTurbo.drainBuffer();
+  },
+
+  /** Drop all references; safe to call from `applicationWillTerminate`. */
+  close(): Promise<void> {
+    return MovexGeoTurbo.close();
+  },
+};
+
+export default MovexGeo;

package/src/NativeMovexGeo.ts

@@ -0,0 +1,42 @@
+/**
+ * TurboModule Codegen spec. RN's Codegen reads this file at the
+ * consumer-app build step (gradle / pod install) and generates the
+ * Java + Obj-C++ glue that the native module implements.
+ *
+ * Type rules (subset that Codegen accepts):
+ *   - `string`, `number`, `boolean`
+ *   - `Object` / `{ [k: string]: ... }` for opaque maps
+ *   - readonly arrays
+ *   - `Promise<T>` for async returns
+ *   - `void` returns become non-Promise on the native side
+ *
+ * Don't import the public `Endpoints` / `TrackResponse` types here —
+ * Codegen needs primitive shapes; complex shapes go through
+ * `Object` and the JS wrapper at `MovexGeo.ts` casts back to the
+ * documented types.
+ */
+
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  initialize(publishableKey: string, endpoints: Object): Promise<void>;
+  setUserId(userId: string | null): Promise<void>;
+  getDeviceId(): Promise<string>;
+  verify(): Promise<Object>;
+  trackOnce(lat: number, lng: number, accuracyM: number): Promise<Object>;
+  startTracking(preset: string): Promise<void>;
+  stopTracking(): Promise<void>;
+  setDevMode(enabled: boolean): Promise<void>;
+  bufferedCount(): Promise<number>;
+  drainBuffer(): Promise<void>;
+  close(): Promise<void>;
+
+  // NativeEventEmitter plumbing — required by RN even for TurboModules
+  // when we surface events. The Spec must declare these stubs;
+  // implementations live in the native module.
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('MovexGeo');

package/src/index.ts

@@ -0,0 +1,17 @@
+// Public entry point. Consumers do:
+//
+//   import MovexGeo from '@movexgeo/react-native-movex';
+//
+//   // or pull individual types:
+//   import type {
+//     Endpoints, Preset, ProjectInfo, MovexGeoEvent, TrackResponse,
+//   } from '@movexgeo/react-native-movex';
+
+export { default } from './MovexGeo';
+export * from './types';
+export type {
+  EventsHandler,
+  EventsSubscription,
+  LocationsHandler,
+  LocationsSubscription,
+} from './MovexGeo';