@wayq/beekon-rn 0.0.3 → 0.0.6

package/src/NativeBeekonRn.ts

@@ -1,60 +1,205 @@
 /**
- * Codegen TurboModule spec — DO NOT export Wire* types from `src/index.tsx`.
- * The public TS API in `src/beekon.ts` and `src/types/` is what consumers use;
- * mappers in `src/internal/mappers.ts` convert between the two.
+ * Codegen TurboModule spec — the single source React Native's Codegen reads to
+ * generate the native interface. **DO NOT export Wire* types from
+ * `src/index.tsx`.** The public TS API in `src/beekon.ts` and `src/types/` is
+ * what consumers use; mappers in `src/internal/mappers.ts` convert between the
+ * two.
  *
- * Wire types are flat (primitives + nested flat objects) because Codegen's
- * TS-to-Kotlin/ObjC type derivation has limited support for unions and
- * recursive structures. The state variants are encoded as a `type`
- * discriminator string with sibling fields nullable per variant.
+ * Wire types are deliberately **flat** (primitives + flat nested objects +
+ * arrays) because Codegen's TS→Kotlin/ObjC derivation has no support for unions
+ * or recursive structures:
+ *
+ * - **Enums travel as plain `string`** (e.g. `accuracyMode`, `quality`); the
+ *   mappers translate to/from the public string-literal unions with a defensive
+ *   fallback, so an unknown value never crashes a subscriber.
+ * - **Sum types** (`WireState`, `WireSyncStatus`) are a `type` discriminator
+ *   string plus sibling fields nullable per variant.
+ * - **String maps** (`headers`, `extras`) travel as `WireKeyValue[]` pairs —
+ *   Codegen has no portable dictionary type.
+ * - **Timestamps** are epoch-milliseconds; intervals are seconds.
  */
 import type { CodegenTypes, TurboModule } from 'react-native';
 import { TurboModuleRegistry } from 'react-native';
 
-export type WireAndroidNotification = {
+/** A single string map entry — see `headers` / `setExtras`. */
+export type WireKeyValue = {
+  key: string;
+  value: string;
+};
+
+/** Flat wire form of `AuthResponseMapping`. Omitted keys use common-name detection. */
+export type WireAuthResponseMapping = {
+  accessToken?: string;
+  refreshToken?: string;
+  expiresIn?: string;
+  expiresAt?: string;
+};
+
+/**
+ * Flat wire form of `AuthConfig` on {@link WireSyncConfig.auth}. Enums travel as
+ * strings (`strategy`: 'bearer'|'raw'; `refreshBodyFormat`: 'form'|'json'),
+ * string maps as `WireKeyValue[]`, and `expiresAtMs` is epoch milliseconds.
+ */
+export type WireAuthConfig = {
+  accessToken?: string;
+  refreshToken?: string;
+  expiresAtMs?: number;
+  strategy: string;
+  refreshUrl?: string;
+  refreshPayload: WireKeyValue[];
+  refreshHeaders: WireKeyValue[];
+  refreshBodyFormat: string;
+  responseMapping: WireAuthResponseMapping;
+  skewMarginSeconds: number;
+  seedEpoch?: number;
+};
+
+export type WireSyncConfig = {
+  url: string;
+  headers: WireKeyValue[];
+  intervalSeconds: number;
+  batchSize: number;
+  /** Token-refresh recipe; omitted keeps static-header auth. */
+  auth?: WireAuthConfig;
+};
+
+/** Android-only foreground-service notification overrides. iOS ignores it. */
+export type WireNotificationConfig = {
   title?: string;
   text?: string;
-  smallIconResName?: string;
+  smallIcon?: string;
 };
 
 export type WireConfig = {
-  /** Required at the wire level — the TS facade applies defaults (30 / 100). */
-  intervalSeconds: number;
-  /** Required at the wire level — the TS facade applies defaults (30 / 100). */
-  distanceMeters: number;
-  /** Android-only. iOS native module ignores. */
-  androidNotification?: WireAndroidNotification;
+  /** All fields required at the wire level — the TS facade applies defaults. */
+  minTimeBetweenLocationsSeconds: number;
+  minDistanceBetweenLocationsMeters: number;
+  /** One of: 'high' | 'balanced' | 'low'. */
+  accuracyMode: string;
+  /** One of: 'keepTracking' | 'pause' | 'pauseWithCheckIns'. */
+  whenStationary: string;
+  stationaryRadiusMeters: number;
+  detectActivity: boolean;
+  /** Omitted keeps tracking local-only. */
+  sync?: WireSyncConfig;
+  /** Android-only; the iOS native module ignores it. */
+  notification?: WireNotificationConfig;
 };
 
 export type WireLocation = {
+  id: string;
   lat: number;
   lng: number;
   timestampMs: number;
-  /** `null` when the OS did not report a value (e.g. low-confidence fix). */
+  /** `null` when the OS did not report a value. */
   accuracy: number | null;
   speed: number | null;
   bearing: number | null;
   altitude: number | null;
+  /** One of: 'ok' | 'lowAccuracy' | 'implausibleSpeed'. */
+  quality: string;
+  /** One of: 'interval' | 'motion' | 'checkIn' | 'geofence' | 'manual'. */
+  trigger: string;
+  /** One of: 'moving' | 'stationary' | 'unknown'. */
+  motion: string;
+  /** Activity enum string, or `null` unless activity detection is enabled. */
+  activity: string | null;
+  isMock: boolean;
+};
+
+export type WireGeofence = {
+  id: string;
+  lat: number;
+  lng: number;
+  radiusMeters: number;
+  notifyOnEntry: boolean;
+  notifyOnExit: boolean;
+};
+
+export type WireGeofenceEvent = {
+  id: string;
+  geofenceId: string;
+  /** One of: 'enter' | 'exit'. */
+  type: string;
+  timestampMs: number;
 };
 
 export type WireState = {
   /** One of: 'idle' | 'tracking' | 'stopped'. */
   type: string;
   /**
-   * Only populated when `type === 'stopped'`. One of:
-   * 'user' | 'permissionDenied' | 'locationServicesDisabled' | 'system'.
+   * Only populated when `type === 'stopped'`. One of: 'user' |
+   * 'permissionDenied' | 'locationServicesDisabled' | 'locationUnavailable' |
+   * 'system'.
    */
   stopReason?: string;
 };
 
+export type WireSyncStatus = {
+  /** One of: 'idle' | 'pending' | 'failed'. */
+  type: string;
+  /** Only populated when `type === 'failed'`. One of: 'auth' | 'rejected'. */
+  failure?: string;
+};
+
+/**
+ * A token set the SDK rotated, delivered on `onAuthTokens`. `expiresAtMs` is
+ * epoch milliseconds; both it and `refreshToken` are `null` when absent.
+ */
+export type WireAuthTokens = {
+  accessToken: string;
+  refreshToken: string | null;
+  expiresAtMs: number | null;
+  epoch: number;
+};
+
 export interface Spec extends TurboModule {
-  configure(config: WireConfig): Promise<void>;
+  /**
+   * The config crosses as an untyped object (`ReadableMap` on Android,
+   * `NSDictionary` on iOS) and is parsed natively. Typing it as the nested
+   * {@link WireConfig} struct would force the iOS ObjC++ layer to walk Codegen's
+   * generated C++ structs; the facade still builds a `WireConfig`-shaped value
+   * via `configToWire`, so the shape is enforced upstream.
+   */
+  configure(config: CodegenTypes.UnsafeObject): Promise<void>;
   start(): Promise<void>;
   stop(): Promise<void>;
-  history(fromMs: number, toMs: number): Promise<WireLocation[]>;
+  resumeIfNeeded(): Promise<void>;
+
+  /**
+   * One immediate fix. `accuracy` `''` uses the configured mode (a plain
+   * `string` rather than `string | null` for portable Codegen, matching
+   * `deleteLocations`). Resolves a 0- or 1-element array — empty means timeout /
+   * no fix — rather than a nullable struct, which Codegen does not portably
+   * support. Rejects with `PERMISSION_DENIED` / `LOCATION_SERVICES_DISABLED` /
+   * `LOCATION_UNAVAILABLE` on a precondition failure.
+   */
+  getCurrentLocation(
+    timeoutMs: number,
+    accuracy: string
+  ): Promise<WireLocation[]>;
+
+  getLocations(fromMs: number, toMs: number): Promise<WireLocation[]>;
+  /**
+   * A negative `beforeMs` deletes all stored locations (the wire encoding of
+   * the public `deleteLocations()` no-argument case). A plain `number` is used
+   * rather than `number | null` for portable Codegen support across platforms.
+   */
+  deleteLocations(beforeMs: number): Promise<number>;
+  pendingUploadCount(): Promise<number>;
+
+  sync(): Promise<void>;
+  setExtras(entries: WireKeyValue[]): Promise<void>;
+
+  addGeofences(geofences: WireGeofence[]): Promise<void>;
+  removeGeofences(ids: string[]): Promise<void>;
+  listGeofences(): Promise<WireGeofence[]>;
 
   readonly onState: CodegenTypes.EventEmitter<WireState>;
   readonly onLocation: CodegenTypes.EventEmitter<WireLocation>;
+  readonly onGeofenceEvent: CodegenTypes.EventEmitter<WireGeofenceEvent>;
+  readonly onSyncStatus: CodegenTypes.EventEmitter<WireSyncStatus>;
+  readonly onAuthTokens: CodegenTypes.EventEmitter<WireAuthTokens>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('BeekonRn');

package/src/beekon.ts

@@ -1,111 +1,341 @@
 import NativeBeekon from './NativeBeekonRn';
+import type { AuthTokens } from './types/auth';
 import type { BeekonConfig } from './types/config';
-import type { BeekonState } from './types/state';
+import type { AccuracyMode } from './types/enums';
+import type { BeekonGeofence, GeofenceEvent } from './types/geofence';
 import type { Location } from './types/location';
+import type { BeekonState } from './types/state';
+import type { SyncStatus } from './types/sync';
 import {
   configToWire,
+  geofenceToWire,
+  recordToEntries,
+  rethrowAsBeekonError,
+  wireToAuthTokens,
+  wireToGeofence,
+  wireToGeofenceEvent,
   wireToLocation,
   wireToState,
-  rethrowAsBeekonError,
+  wireToSyncStatus,
 } from './internal/mappers';
 
+type Listener<T> = (value: T) => void;
+
 /**
- * Public facade for the Beekon SDK. Mirrors the native APIs:
+ * Fans the five native EventEmitters out to multiple JS subscribers and adds
+ * replay-1 semantics for `state` / `syncStatus` / `authTokens` (RN EventEmitters
+ * don't replay, so we cache the latest value and hand it to new subscribers
+ * immediately — matching the native StateFlow / AsyncStream contract).
+ * `location` / `geofenceEvent` are plain fan-out with no replay.
+ *
+ * Native subscriptions are opened once, on first use, and kept for the app
+ * lifetime — the native module collects its flows continuously regardless, so
+ * this only keeps the JS cache warm.
+ */
+class EventHub {
+  private subscribed = false;
+  private readonly stateListeners = new Set<Listener<BeekonState>>();
+  private readonly locationListeners = new Set<Listener<Location>>();
+  private readonly geofenceListeners = new Set<Listener<GeofenceEvent>>();
+  private readonly syncListeners = new Set<Listener<SyncStatus>>();
+  private readonly authTokenListeners = new Set<Listener<AuthTokens>>();
+  private lastState: BeekonState | undefined;
+  private lastSyncStatus: SyncStatus | undefined;
+  private lastAuthTokens: AuthTokens | undefined;
+
+  /** Idempotent: opens the native subscriptions the first time it is called. */
+  ensureSubscribed(): void {
+    if (this.subscribed) return;
+    this.subscribed = true;
+    NativeBeekon.onState((w) => {
+      const s = wireToState(w);
+      this.lastState = s;
+      this.stateListeners.forEach((cb) => cb(s));
+    });
+    NativeBeekon.onLocation((w) => {
+      const l = wireToLocation(w);
+      this.locationListeners.forEach((cb) => cb(l));
+    });
+    NativeBeekon.onGeofenceEvent((w) => {
+      const g = wireToGeofenceEvent(w);
+      this.geofenceListeners.forEach((cb) => cb(g));
+    });
+    NativeBeekon.onSyncStatus((w) => {
+      const s = wireToSyncStatus(w);
+      this.lastSyncStatus = s;
+      this.syncListeners.forEach((cb) => cb(s));
+    });
+    NativeBeekon.onAuthTokens((w) => {
+      const t = wireToAuthTokens(w);
+      this.lastAuthTokens = t;
+      this.authTokenListeners.forEach((cb) => cb(t));
+    });
+  }
+
+  onState(cb: Listener<BeekonState>): () => void {
+    this.ensureSubscribed();
+    this.stateListeners.add(cb);
+    if (this.lastState !== undefined) cb(this.lastState);
+    return () => {
+      this.stateListeners.delete(cb);
+    };
+  }
+
+  onLocation(cb: Listener<Location>): () => void {
+    this.ensureSubscribed();
+    this.locationListeners.add(cb);
+    return () => {
+      this.locationListeners.delete(cb);
+    };
+  }
+
+  onGeofenceEvent(cb: Listener<GeofenceEvent>): () => void {
+    this.ensureSubscribed();
+    this.geofenceListeners.add(cb);
+    return () => {
+      this.geofenceListeners.delete(cb);
+    };
+  }
+
+  onSyncStatus(cb: Listener<SyncStatus>): () => void {
+    this.ensureSubscribed();
+    this.syncListeners.add(cb);
+    if (this.lastSyncStatus !== undefined) cb(this.lastSyncStatus);
+    return () => {
+      this.syncListeners.delete(cb);
+    };
+  }
+
+  onAuthTokens(cb: Listener<AuthTokens>): () => void {
+    this.ensureSubscribed();
+    this.authTokenListeners.add(cb);
+    if (this.lastAuthTokens !== undefined) cb(this.lastAuthTokens);
+    return () => {
+      this.authTokenListeners.delete(cb);
+    };
+  }
+}
+
+/**
+ * Public facade for the Beekon SDK — a 1:1 mirror of the native APIs:
  *
  * - Android: `in.wayq.beekon.Beekon` (object)
  * - iOS:     `BeekonKit.Beekon.shared` (actor)
  *
- * Lifecycle: `configure(config)` → `start()` → ... → `stop()` (idempotent).
- * Subscribe to `onState` / `onLocation` for live updates; query
- * `history(from, to)` for persisted fixes.
+ * There is **no `initialize()`** — the native SDKs auto-initialize. Lifecycle:
+ * `configure(config)` (optional; defaults 30s / 100m) → `start()` → … →
+ * `stop()`. `start()` / `stop()` **never throw** — `onState` is the single
+ * source of truth for whether tracking is active and why it stopped.
  *
- * **Threading:** Methods are safe to call from any JS context. Subscribers'
+ * **Threading:** methods are safe to call from any JS context; subscriber
  * callbacks fire on the JS thread.
  *
- * **Persistence invariant:** the SDK persists every gated fix natively; JS is
- * a passive observer. In background, the JS engine is not guaranteed to be
- * alive — for past fixes, use `history()`.
+ * **Persistence invariant:** the SDK persists every gated fix natively; JS is a
+ * passive observer that is not guaranteed to be alive in the background. For
+ * past fixes use `getLocations()`.
  */
 class BeekonImpl {
+  private readonly hub = new EventHub();
+
   /**
    * Set tracking parameters. Optional — `start()` falls back to the previously
-   * persisted config or the SDK default (30s / 100m) if never configured.
-   *
-   * While tracking, the new gate values take effect on the next admitted fix
-   * without restarting the underlying location subscription.
+   * persisted config, or the SDK defaults if never configured. While tracking,
+   * gate thresholds take effect on the next admitted fix without restarting the
+   * location subscription; `accuracyMode` applies on the next `start()`.
    */
   async configure(config: BeekonConfig): Promise<void> {
+    this.hub.ensureSubscribed();
+    await NativeBeekon.configure(configToWire(config));
+  }
+
+  /**
+   * Begin tracking. Never throws — observe `onState` for the outcome
+   * (`stopped(reason)` on a permission / services / system problem). Beekon
+   * ships no permission API: request permissions in the host app, then observe
+   * `onState`.
+   */
+  async start(): Promise<void> {
+    this.hub.ensureSubscribed();
+    await NativeBeekon.start();
+  }
+
+  /** Stop tracking. Idempotent. Registered geofences keep firing. */
+  async stop(): Promise<void> {
+    this.hub.ensureSubscribed();
+    await NativeBeekon.stop();
+  }
+
+  /**
+   * Resume tracking if a session was active before the app was terminated. A
+   * no-op if the user explicitly stopped. Call early in app startup.
+   *
+   * Note: on a background relaunch the JS engine may not be running, so true
+   * cold-launch resume also requires native host wiring (Android: call
+   * `Beekon.start()` from `Application.onCreate`; iOS: `registerBackgroundTasks`
+   * in the AppDelegate). See the README.
+   */
+  async resumeIfNeeded(): Promise<void> {
+    this.hub.ensureSubscribed();
+    await NativeBeekon.resumeIfNeeded();
+  }
+
+  /**
+   * Return a single fresh fix on demand — for the moment a host needs an
+   * immediate position (e.g. the instant a trip starts).
+   *
+   * Independent of tracking: works whether or not a session is running and never
+   * starts, stops, or disturbs one. The fix is not persisted and does not appear
+   * on `onLocation` — it is returned here only, tagged `'manual'`.
+   *
+   * Resolves `null` if no usable fix arrives within `timeoutMs` (default
+   * 15000). `accuracy` overrides the configured mode for this call only;
+   * omitted uses the configured mode.
+   *
+   * Throws `BeekonError` with kind `'permissionDenied'`,
+   * `'locationServicesDisabled'`, or `'locationUnavailable'` on a precondition
+   * failure.
+   */
+  async getCurrentLocation(options?: {
+    timeoutMs?: number;
+    accuracy?: AccuracyMode;
+  }): Promise<Location | null> {
     try {
-      await NativeBeekon.configure(configToWire(config));
+      const wires = await NativeBeekon.getCurrentLocation(
+        options?.timeoutMs ?? 15000,
+        options?.accuracy ?? ''
+      );
+      return wires.length === 0 ? null : wireToLocation(wires[0]!);
     } catch (e) {
       rethrowAsBeekonError(e);
     }
   }
 
   /**
-   * Begin tracking. State transitions to `tracking`.
+   * Read persisted fixes in the inclusive range `[from, to]`, oldest first.
+   * Reads come from the SDK's local storage (Room on Android, GRDB on iOS) — the
+   * source of truth even when JS was asleep. With sync enabled, rows are deleted
+   * locally once the server accepts them, so this returns only un-uploaded fixes.
    *
-   * Throws a `BeekonError` with kind:
-   * - `'permissionDenied'` — location permission not granted.
-   * - `'locationServicesDisabled'` — system location services off (or GMS
-   *   unavailable on Android).
+   * Throws `BeekonError` with kind `'storage'` on a database read failure.
    */
-  async start(): Promise<void> {
+  async getLocations(from: Date, to: Date): Promise<Location[]> {
     try {
-      await NativeBeekon.start();
+      const wires = await NativeBeekon.getLocations(
+        from.getTime(),
+        to.getTime()
+      );
+      return wires.map(wireToLocation);
     } catch (e) {
       rethrowAsBeekonError(e);
     }
   }
 
-  /** Stop tracking. Idempotent. State transitions to `stopped(user)`. */
-  async stop(): Promise<void> {
+  /**
+   * Delete stored locations captured before `before` (all of them when
+   * `before` is omitted). Returns the number of rows removed. Throws
+   * `BeekonError` with kind `'storage'` on a failure.
+   */
+  async deleteLocations(before?: Date): Promise<number> {
     try {
-      await NativeBeekon.stop();
+      // Negative is the wire sentinel for "delete all" (see NativeBeekonRn.ts).
+      return await NativeBeekon.deleteLocations(before ? before.getTime() : -1);
     } catch (e) {
       rethrowAsBeekonError(e);
     }
   }
 
   /**
-   * Read persisted fixes in the time range [from, to]. Returns fixes in
-   * chronological order. Reads come from the SDK's local storage (Room on
-   * Android, GRDB on iOS) — the source of truth even when JS was asleep.
-   *
-   * Retention: fixes older than 7 days OR beyond the most recent 100K are
-   * pruned automatically.
-   *
-   * Throws `BeekonError` with kind `'storageFailure'` on database read failure.
+   * The number of stored locations not yet uploaded. Throws `BeekonError` with
+   * kind `'storage'` on a failure.
    */
-  async history(from: Date, to: Date): Promise<Location[]> {
+  async pendingUploadCount(): Promise<number> {
     try {
-      const wires = await NativeBeekon.history(from.getTime(), to.getTime());
-      return wires.map(wireToLocation);
+      return await NativeBeekon.pendingUploadCount();
     } catch (e) {
       rethrowAsBeekonError(e);
     }
   }
 
   /**
-   * Subscribe to state transitions. Returns an unsubscribe function. The
-   * current state is delivered to new subscribers immediately (replay-1
-   * semantics, matching the native `state` flow / AsyncStream).
+   * Request an immediate upload. Best-effort and self-retrying; a no-op when
+   * sync is not configured.
+   */
+  async sync(): Promise<void> {
+    await NativeBeekon.sync();
+  }
+
+  /** Set custom key/value fields (e.g. `user_id`) included with every upload. */
+  async setExtras(extras: Record<string, string>): Promise<void> {
+    await NativeBeekon.setExtras(recordToEntries(extras));
+  }
+
+  /**
+   * Register geofences. Re-adding an `id` replaces the existing one. Throws
+   * `BeekonError` with kind `'invalidGeofence'` if any entry fails validation —
+   * none are added when one is invalid.
+   */
+  async addGeofences(geofences: BeekonGeofence[]): Promise<void> {
+    try {
+      await NativeBeekon.addGeofences(geofences.map(geofenceToWire));
+    } catch (e) {
+      rethrowAsBeekonError(e);
+    }
+  }
+
+  /** Unregister geofences by id. Unknown ids are ignored. */
+  async removeGeofences(ids: string[]): Promise<void> {
+    await NativeBeekon.removeGeofences(ids);
+  }
+
+  /** The currently registered geofences. */
+  async listGeofences(): Promise<BeekonGeofence[]> {
+    const wires = await NativeBeekon.listGeofences();
+    return wires.map(wireToGeofence);
+  }
+
+  /**
+   * Subscribe to tracking-state transitions (`idle` / `tracking` /
+   * `stopped(reason)`). The current state is delivered to new subscribers
+   * immediately (replay-1). Returns an unsubscribe function.
    */
   onState(cb: (s: BeekonState) => void): () => void {
-    const subscription = NativeBeekon.onState((wire) => cb(wireToState(wire)));
-    return () => subscription.remove();
+    return this.hub.onState(cb);
   }
 
   /**
-   * Subscribe to gated locations as they arrive. Returns an unsubscribe
-   * function. Broadcast (no replay) — only delivers while the JS engine is
-   * alive. For fixes emitted while JS was asleep, use `history()`.
+   * Subscribe to gated locations as they arrive. Broadcast (no replay) — only
+   * delivers while the JS engine is alive. For fixes emitted while JS was
+   * asleep, use `getLocations()`. Returns an unsubscribe function.
    */
   onLocation(cb: (l: Location) => void): () => void {
-    const subscription = NativeBeekon.onLocation((wire) =>
-      cb(wireToLocation(wire))
-    );
-    return () => subscription.remove();
+    return this.hub.onLocation(cb);
+  }
+
+  /**
+   * Subscribe to geofence enter / exit crossings. Broadcast (no replay).
+   * Returns an unsubscribe function.
+   */
+  onGeofenceEvent(cb: (e: GeofenceEvent) => void): () => void {
+    return this.hub.onGeofenceEvent(cb);
+  }
+
+  /**
+   * Subscribe to upload health (`idle` / `pending` / `failed(reason)`). The
+   * current status is delivered to new subscribers immediately (replay-1).
+   * Returns an unsubscribe function.
+   */
+  onSyncStatus(cb: (s: SyncStatus) => void): () => void {
+    return this.hub.onSyncStatus(cb);
+  }
+
+  /**
+   * Subscribe to token rotations the SDK performed during a native refresh (see
+   * `SyncConfig.auth`). Mirror them into your own session store. The latest
+   * rotation is delivered to new subscribers immediately (replay-1). Sensitive —
+   * delivered in-process only, never logged. Returns an unsubscribe function.
+   */
+  onAuthTokens(cb: (t: AuthTokens) => void): () => void {
+    return this.hub.onAuthTokens(cb);
   }
 }
 

package/src/index.tsx

@@ -1,5 +1,27 @@
 export { Beekon } from './beekon';
-export type { BeekonConfig, AndroidNotificationConfig } from './types/config';
-export type { BeekonState, StopReason } from './types/state';
+
+export type {
+  BeekonConfig,
+  SyncConfig,
+  NotificationConfig,
+} from './types/config';
+export type {
+  AccuracyMode,
+  StationaryMode,
+  LocationTrigger,
+  LocationQuality,
+  MotionState,
+  ActivityType,
+  AuthStrategy,
+  AuthBodyFormat,
+} from './types/enums';
+export type { AuthConfig, AuthResponseMapping, AuthTokens } from './types/auth';
 export type { Location } from './types/location';
+export type {
+  BeekonGeofence,
+  GeofenceEvent,
+  Transition,
+} from './types/geofence';
+export type { BeekonState, StopReason } from './types/state';
+export type { SyncStatus, SyncFailure } from './types/sync';
 export { BeekonError, type BeekonErrorKind } from './types/error';