@transistorsoft/background-geolocation-types 5.0.0-beta.3 → 5.0.0-beta.4

package/dist/core/api/BackgroundGeolocation.d.ts

@@ -23,10 +23,6 @@ import type { AuthorizationStatus } from '../../enums/AuthorizationStatus';
 import type { LogLevel } from '../../enums/LogLevel';
 import type { PersistMode } from '../../enums/PersistMode';
 import type { AccuracyAuthorization } from '../../enums/AccuracyAuthorization';
-/**
- * Payloads for strongly-typed event listeners.
- * @internal @hidden
- */
 export interface EventPayloads {
     location: Location;
     motionchange: MotionChangeEvent;
@@ -52,1630 +48,83 @@ export interface EventPayloads {
     };
     [event: string]: any;
 }
-/**
- * on/once/remove… with typed payloads.
- * @internal @hidden
- */
 export interface BackgroundGeolocationEvents {
-    /**
-    * Subscribe to location events.
-    *
-    * Every location recorded by the SDK is provided to your `callback`, including those from [[onMotionChange]], [[getCurrentPosition]] and [[watchPosition]].
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onLocation((location) => {
-    *   console.log("[onLocation] success: ", location);
-    * }, (error) => {
-    *   console.log("[onLocation] ERROR: ", error);
-    * });
-    * ```
-    *
-    * __Error Codes__
-    *
-    * If the native location API fails to return a location, the `failure` callback will be provided a [[LocationError]].
-    *
-    * __⚠️ Note {@link Location.sample|`Location.sample`}:__
-    *
-    * When performing a {@link onMotionChange} or {@link getCurrentPosition}, the plugin requests **multiple** location *samples* in order to record the most accurate location possible.  These *samples* are **not** persisted to the database but they will be provided to your `callback`, for your convenience, since it can take some seconds for the best possible location to arrive.
-    *
-    * For example, you might use these samples to progressively update the user's position on a map.  You can detect these *samples* in your `callback` via `location.sample == true`.  If you're manually `POST`ing location to your server, you should ignore these locations.
-    *
-    * @event location
-    */
     onLocation(cb: (location: Location) => void, onError?: (err: LocationError) => void): Subscription;
-    /**
-    * Subscribe to __`motionchange`__ events.
-    *
-    * Your `callback` will be executed each time the device has changed-state between **MOVING** or **STATIONARY**.
-    *
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onMotionChange((event:MotionChangeEvent) => {
-    *   if (event.isMoving) {
-    *      console.log("[onMotionChange] Device has just started MOVING ", event.location);
-    *   } else {
-    *      console.log("[onMotionChange] Device has just STOPPED:  ", event.location);
-    *   }
-    * });
-    * ```
-    *
-    * ----------------------------------------------------------------------
-    * __⚠️ Warning:  `autoSyncThreshold`__
-    *
-    * If you've configured [[Config.autoSyncThreshold]], it **will be ignored** during a `onMotionChange` event — all queued locations will be uploaded, since:
-    * - If an `onMotionChange` event fires **into the *moving* state**, the device may have been sitting dormant for a long period of time.  The plugin is *eager* to upload this state-change to the server as soon as possible.
-    * - If an `onMotionChange` event fires **into the *stationary* state**, the device may be about to lie dormant for a long period of time.  The plugin is *eager* to upload all queued locations to the server before going dormant.
-    * ----------------------------------------------------------------------
-    *
-    * __ℹ️ See also:__
-    * - {@link GeoConfig.stopTimeout}
-    * - 📘 [Philosophy of Operation](github:wiki/Philosophy-of-Operation)
-    *
-    * @event motionchange
-    */
     onMotionChange(cb: (event: MotionChangeEvent) => void): Subscription;
-    /**
-    * Subscribe to Geofence transition events.
-    *
-    * Your supplied `callback` will be called when any monitored geofence crossing occurs.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onGeofence((event) => {
-    *   console.log("[onGeofence] ", event);
-    * });
-    * ```
-    *
-    * __ℹ️ See also:
-    * - 📘 {@link Geofence | Geofencing Guide}
-    *
-    * @event geofence
-    */
     onGeofence(cb: (event: GeofenceEvent) => void): Subscription;
-    /**
-    * Subscribe to changes in actively monitored geofences.
-    *
-    * Fired when the list of monitored-geofences changed.  The BackgroundGeolocation SDK contains powerful geofencing features that allow you to monitor
-    * any number of circular geofences you wish (thousands even), in spite of limits imposed by the native platform APIs (**20 for iOS; 100 for Android**).
-    *
-    * The plugin achieves this by storing your geofences in its database, using a [geospatial query](https://en.wikipedia.org/wiki/Spatial_query) to determine
-    * those geofences in proximity (@see {@link GeoConfig.geofenceProximityRadius}), activating only those geofences closest to the device's current location
-    * (according to limit imposed by the corresponding platform).
-    *
-    * When the device is determined to be moving, the plugin periodically queries for geofences in proximity (eg. every minute) using the latest recorded
-    * location.  This geospatial query is **very fast**, even with tens-of-thousands geofences in the database.
-    *
-    * It's when this list of monitored geofences *changes*, that the plugin will fire the `onGeofencesChange` event.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onGeofencesChange((event) => {
-    *   let on = event.on;     //<-- new geofences activated.
-    *   let off = event.off; //<-- geofences that were just de-activated.
-    *
-    *   // Create map circles
-    *   on.forEach((geofence) => {
-    *     createGeofenceMarker(geofence)
-    *   });
-    *
-    *   // Remove map circles
-    *   off.forEach((identifier) => {
-    *     removeGeofenceMarker(identifier);
-    *   }
-    * });
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - 📘 {@link Geofence | Geofencing Guide}
-    * @event geofenceschange
-    */
     onGeofencesChange(cb: (event: GeofencesChangeEvent) => void): Subscription;
-    /**
-    * Subscribe to changes in motion activity.
-    *
-    * Your `callback` will be executed each time the activity-recognition system receives an event (`still, on_foot, in_vehicle, on_bicycle, running`).
-    *
-    * __Android:__
-    * Android {@link MotionActivityEvent.confidence} always reports `100%`.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onActivityChange((event) => {
-    *   console.log("[onActivityChange] ", event);
-    * });
-    * ```
-    * @event activitychange
-    */
     onActivityChange(cb: (event: MotionActivityEvent) => void): Subscription;
-    /**
-    * Subscribe to changes in device's location-services configuration / authorization.
-    *
-    * Your `callback` fill be executed whenever a change in the state of the device's **Location Services** has been detected.  eg: "GPS ON", "WiFi only".
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onProviderChange((event) => {
-    *   console.log("[onProviderChange: ", event);
-    *
-    *   switch(event.status) {
-    *     case BackgroundGeolocation.AUTHORIZATION_STATUS_DENIED:
-    *       // Android & iOS
-    *       console.log("- Location authorization denied");
-    *       break;
-    *     case BackgroundGeolocation.AUTHORIZATION_STATUS_ALWAYS:
-    *       // Android & iOS
-    *       console.log("- Location always granted");
-    *       break;
-    *     case BackgroundGeolocation.AUTHORIZATION_STATUS_WHEN_IN_USE:
-    *       // iOS only
-    *       console.log("- Location WhenInUse granted");
-    *       break;
-    *   }
-    * });
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - You can explicitly request the current state of location-services using [[getProviderState]].
-    *
-    * __⚠️ Note:__
-    * - The plugin always force-fires an {@link onProviderChange} event whenever the app is launched (right after the {@link ready} method is executed), regardless of current state, so you can learn the the current state of location-services with each boot of your application.
-    *
-    * @event providerchange
-    */
     onProviderChange(cb: (event: ProviderChangeEvent) => void): Subscription;
-    /**
-    * Subscribe to periodic heartbeat events.
-    *
-    * Your `callback` will be executed for each {@link AppConfig.heartbeatInterval} while the device is in **stationary** state (**iOS** requires {@link AppConfig.preventSuspend}: true as well).
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.ready({
-    *   heartbeatInterval: 60,
-    *   preventSuspend: true // <-- Required for iOS
-    * });
-    *
-    * const subscription = BackgroundGeolocation.onHeartbeat((event) => {
-    *   console.log("[onHeartbeat] ", event);
-    *
-    *   // You could request a new location if you wish.
-    *   BackgroundGeolocation.getCurrentPosition({
-    *     samples: 1,
-    *     persist: true
-    *   }).then((location) => {
-    *     console.log("[getCurrentPosition] ", location);
-    *   });
-    * })
-    * ```
-    *
-    * __⚠️ Note:__
-    * -  The {@link Location} provided by the {@link HeartbeatEvent} is only the last-known location.  The *heartbeat* event does not actively engage location-services.  If you wish to get the current location in your `callback`, use {@link getCurrentPosition}.
-    * @event heartbeat
-    */
     onHeartbeat(cb: (event: HeartbeatEvent) => void): Subscription;
-    /**
-    * Subscribe to HTTP responses from your server {@link HttpConfig.url}.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onHttp((response) => {
-    *   let status = response.status;
-    *   let success = response.success;
-    *   let responseText = response.responseText;
-    *   console.log("[onHttp] ", response);
-    * });
-    * ```
-    * __ℹ️ See also:__
-    *  - {@link HttpConfig | HTTP Guide}
-    *
-    * @event http
-    */
     onHttp(cb: (event: HttpEvent) => void): Subscription;
-    /**
-    * Subscribe to {@link AppConfig.schedule} events.
-    *
-    * Your `callback` will be executed each time a {@link AppConfig.schedule} event fires.  Your `callback` will be provided with the current {@link State}:  **`state.enabled`**
-    * will reflect the state according to your {@link AppConfig.schedule}.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onSchedule((state) => {
-    *   if (state.enabled) {
-    *     console.log("[onSchedule] scheduled start tracking");
-    *   } else {
-    *     console.log("[onSchedule] scheduled stop tracking");
-    *   }
-    * });
-    * ```
-    * @event schedule
-    */
     onSchedule(cb: (state: State) => void): Subscription;
-    /**
-    * Subscribe to changes in network connectivity.
-    *
-    * Fired when the state of the device's network-connectivity changes (enabled -> disabled and vice-versa).  By default, the plugin will automatically fire
-    * a `connectivitychange` event with the current state network-connectivity whenever the [[start]] method is executed.
-    *
-    * ℹ️ The SDK subscribes internally to `connectivitychange` events &mdash; if you've configured the SDK's HTTP Service (See [[HttpEvent | HTTP Guide]]) and your app has queued locations,
-    * the SDK will automatically initiate uploading to your configured {{@link HttpConfig.url}} when network connectivity is detected.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onConnectivityChange((event) => {
-    *   console.log("[onConnectivityChange] ", event);
-    * });
-    * ```
-    * @event connectivitychange
-    */
     onConnectivityChange(cb: (event: ConnectivityChangeEvent) => void): Subscription;
-    /**
-    * Subscribe to state changes in OS power-saving system.
-    *
-    * Fired when the state of the operating-system's "Power Saving" mode changes.  Your `callback` will be provided with a `bool` showing whether
-    * "Power Saving" is **enabled** or **disabled**.  Power Saving mode can throttle certain services in the background, such as HTTP requests or GPS.
-    *
-    * ℹ️ You can manually request the current-state of "Power Saving" mode with the method [[isPowerSaveMode]].
-    *
-    * __iOS__
-    *
-    * iOS Power Saving mode can be engaged manually by the user in **Settings -> Battery** or from an automatic OS dialog.
-    *
-    * ![](https://dl.dropboxusercontent.com/s/lz3zl2jg4nzstg3/Screenshot%202017-09-19%2010.34.21.png?dl=1)
-    *
-    * __Android__
-    *
-    * Android Power Saving mode can be engaged manually by the user in **Settings -> Battery -> Battery Saver** or automatically with a user-specified "threshold" (eg: 15%).
-    *
-    * ![](https://dl.dropboxusercontent.com/s/raz8lagrqayowia/Screenshot%202017-09-19%2010.33.49.png?dl=1)
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onPowerSaveChange((isPowerSaveMode) => {
-    *   console.log("[onPowerSaveChange: ", isPowerSaveMode);
-    * });
-    * ```
-    * @event powersavechange
-    */
     onPowerSaveChange(cb: (enabled: boolean) => void): Subscription;
-    /**
-    * Subscribe to changes in plugin [[State.enabled]].
-    *
-    * Fired when the SDK's {@link State.enabled} changes.  For example, executing {@link start} and {@link stop} will cause the `onEnabledChange` event to fire.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onEnabledChange(isEnabled => {
-    *   console.log("[onEnabledChanged] isEnabled? ", isEnabled);
-    * });
-    * ```
-    * @event enabledchange
-    */
     onEnabledChange(cb: (enabled: boolean) => void): Subscription;
-    /**
-    * [__Android-only__] Subscribe to button-clicks of a custom {@link NotificationConfig.layout} on the Android foreground-service notification.
-    */
     onNotificationAction(cb: (buttonId: string) => void): Subscription;
-    /**
-    * Subscribe to {@link Config.authorization} events.
-    *
-    * Fired when {@link AuthorizationConfig.refreshUrl} responds, either successfully or not.  If successful, {@link AuthorizationEvent.success} will be `true` and {@link AuthorizationEvent.response} will
-    * contain the decoded JSON response returned from the server.
-    *
-    * If authorization failed, {@link AuthorizationEvent.error} will contain the error message.
-    *
-    * @example
-    * ```typescript
-    * const subscription = BackgroundGeolocation.onAuthorization((event) => {
-    *   if (event.success) {
-    *     console.log("[authorization] ERROR: ", event.error);
-    *   } else {
-    *     console.log("[authorization] SUCCESS: ", event.response);
-    *   }
-    * });
-    * ```
-    * @event authorization
-    */
     onAuthorization(cb: (event: AuthorizationEvent) => void): Subscription;
-    /**
-     * @deprecated Use strongly-typed helpers above.
-     * @hidden
-     */
     addListener(event: string, success: Function, failure?: Function): void;
-    /**
-     * @deprecated Use Subscription.remove() returned by helpers above.
-     * @hidden
-     */
     removeListener(event: string, cb: Function): void;
-    /**
-    * Removes all event-listeners.
-    *
-    * Calls [[Subscription.remove]] on all subscriptions.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.removeListeners();
-    * ```
-    */
     removeListeners(): Promise<void>;
-    /**
-      * Registers a Javascript callback to execute in the Android "Headless" state, where the app has been terminated configured with
-      * {@link AppConfig.stopOnTerminate}:false`.  The received `event` object contains a `name` (the event name) and `params` (the event data-object).
-      *
-      * __⚠️ Note Cordova &amp; Capacitor__
-      * - Javascript headless callbacks are not supported by Cordova or Capacitor.  See [Android Headless Mode](github:wiki/Android-Headless-Mode)
-      *
-      * __⚠️ Warning:__
-      * - You __must__ `registerHeadlessTask` in your application root file (eg: `index.js`).
-      *
-      * __⚠️ Warning:__
-      * - Your `function` __must__ be declared as `async`.  You must `await` all work within your task.  Your headless-task will automatically be terminated after executing the last line of your function.
-      *
-      * @example
-      * ```typescript
-      * const BackgroundGeolocationHeadlessTask = async (event) => {
-      *   const params = event.params;
-      *   console.log("[BackgroundGeolocation HeadlessTask] -", event.name, params);
-      *
-      *   switch (event.name) {
-      *     case "terminate":
-      *       // Use await for async tasks
-      *       const location = await BackgroundGeolocation.getCurrentPosition({
-      *         samples: 1,
-      *         persist: false
-      *       });
-      *       console.log("[BackgroundGeolocation HeadlessTask] - getCurrentPosition:", location);
-      *       break;
-      *   }
-      *   // You must await all work you do in your task.
-      *   // Headless-tasks are automatically terminated after executing the last line of your function.
-      *   await doWork();
-      * }
-      *
-      * BackgroundGeolocation.registerHeadlessTask(BackgroundGeolocationHeadlessTask);
-      * ```
-      *
-      * __Debugging__
-      *
-      * While implementing your headless-task It's crucial to observe your Android logs in a terminal via
-      *
-      * ```bash
-      * $ adb logcat *:S TSLocationManager:V ReactNativeJS:V
-      *
-      * TSLocationManager: [c.t.r.HeadlessTask onHeadlessEvent] 💀  event: connectivitychange
-      * TSLocationManager: [c.t.r.HeadlessTask createReactContextAndScheduleTask] initialize ReactContext
-      * TSLocationManager: [c.t.r.HeadlessTask onHeadlessEvent] 💀  event: providerchange
-      * TSLocationManager: [c.t.r.HeadlessTask onHeadlessEvent] 💀  event: terminate
-      * ReactNativeJS: '[BGGeoHeadlessTask] ', 'connectivitychange', taskId: 1
-      * TSLocationManager: [c.t.r.HeadlessTask invokeStartTask] taskId: 1
-      * TSLocationManager: [c.t.r.HeadlessTask invokeStartTask] taskId: 2
-      * TSLocationManager: [c.t.r.HeadlessTask invokeStartTask] taskId: 3
-      * ReactNativeJS: '[BGGeoHeadlessTask] ', 'providerchange', taskId: 2
-      * ReactNativeJS: '[BGGeoHeadlessTask] ', 'terminate', taskId: 3
-      * TSLocationManager: [c.t.l.u.BackgroundTaskManager$Task start] ⏳ startBackgroundTask: 1
-      * TSLocationManager: [c.t.l.u.BackgroundTaskManager$Task start] ⏳ startBackgroundTask: 2
-      * ReactNativeJS: *** [doWork] START
-      * ReactNativeJS: *** [doWork] START
-      * TSLocationManager: [c.t.l.u.BackgroundTaskManager$Task start] ⏳ startBackgroundTask: 3
-      * ReactNativeJS: *** [doWork] START
-      * .
-      * .
-      * .
-      * ReactNativeJS: *** [doWork] FINISH
-      * ReactNativeJS: *** [doWork] FINISH
-      * ReactNativeJS: *** [doWork] FINISH
-      * TSLocationManager: [c.t.l.u.BackgroundTaskManager$Task stop] ⏳ stopBackgroundTask: 1
-      * TSLocationManager: [c.t.l.u.BackgroundTaskManager$Task stop] ⏳ stopBackgroundTask: 2
-      * TSLocationManager: [c.t.l.u.BackgroundTaskManager$Task stop] ⏳ stopBackgroundTask: 3
-      * TSLocationManager: [c.t.r.HeadlessTask$1 onHeadlessJsTaskFinish] taskId: 1
-      * TSLocationManager: [c.t.r.HeadlessTask$1 onHeadlessJsTaskFinish] taskId: 2
-      * TSLocationManager: [c.t.r.HeadlessTask$1 onHeadlessJsTaskFinish] taskId: 3
-      * ```
-      *
-      * __ℹ️ See also:__
-      * - 📘 [Android Headless Mode](github:wiki/Android-Headless-Mode).
-      * - {@link AppConfig.enableHeadless}
-      *
-      */
     registerHeadlessTask(callback: (event: HeadlessEvent) => Promise<void>): void;
 }
-/**
- * Core SDK API each adapter (RN/Cap/Cordova) implements.
- * Runtime default export should satisfy this interface.
- * @internal @hidden
- */
 export interface BackgroundGeolocationAPI extends BackgroundGeolocationEvents {
-    /**
-     * {@link DeviceSettings} API
-     */
     readonly deviceSettings: DeviceSettings;
-    /**
-     * {@link Logger} API
-     */
     readonly logger: Logger;
-    /**
-    *
-    * Signal to the plugin that your app is launched and ready, proving the default {@link Config}.
-    *
-    * The supplied {@link Config} will be applied **only at first install** of your app — for every launch thereafter,
-    * the plugin will automatically load its last-known configuration from persistent storage.
-    * The plugin always remembers the configuration you apply to it.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.ready({
-    *   desiredAccuracy: BackgroundGeolocation.DESIRED_ACCURACY_HIGH,
-    *   distanceFilter: 10,
-    *   stopOnTerminate: false,
-    *   startOnBoot: true,
-    *   url: "http://your.server.com",
-    *   headers: {
-    *    "my-auth-token": "secret-token"
-    *   }
-    * }).then((state) => {
-    *  console.log("[ready] success", state);
-    * });
-    * ```
-    *
-    * __⚠️ Warning:__
-    * - You must call __`.ready(confg)`__ **once** and **only** once, each time your app is launched.
-    * - Do not hide the call to `.ready(config)` within a view which is loaded only by clicking a UI action.  This is particularly important
-    * for iOS in the case where the OS relaunches your app in the background when the device is detected to be moving.  If you don't ensure that `.ready(config)` is called in this case, tracking will not resume.
-    *
-    * __The {@link reset} method.__
-    *
-    * If you wish, you can use the {@link reset} method to reset all {@link Config} options to documented default-values (with optional overrides):
-    *
-    * __{@link Config.reset}: false__
-    *
-    * Configuring the plugin with __`reset: false`__ should generally be avoided unless you know *exactly* what it does.  People often find this from the *Demo* app.  If you do configure `reset: false`, you'll find that your `Config` provided to `.ready` is consumed **only at first launch after install**.  Thereafter, the plugin will ignore any changes you've provided there.  The only way to change the config then is to use {@link setConfig}.
-    *
-    * You will especially not want to use `reset: false` during development, while you're fine-tuning your `Config` options.
-    *
-    * The reason the *Demo* app uses `reset: false` is because it hosts an advanced "*Settings*" screen to tune the `Config` at runtime and we don't want those runtime changes to be overwritten by `.ready(config)` each time the app launches.
-    *
-    * ⚠️ If you *don't* undestand what __`reset: false`__ does, **NO NOT USE IT**.  If you blindly copy/pasted it from the *Demo* app, **REMOVE IT** from your `Config`.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.reset();
-    * // Reset to documented default-values with overrides
-    * bgGeo.reset({
-    *   distanceFilter:  10
-    * });
-    * ```
-    */
     ready(config: Config): Promise<State>;
-    /**
-    * Resets the SDK configuration to documented default-values.
-    *
-    * If an optional {@link Config} is provided, it will be applied *after* the configuration reset.
-    *
-    */
     reset(config: Config): Promise<State>;
-    /**
-    * Enable location + geofence tracking.
-    *
-    * This is the SDK's power **ON** button.  The plugin will initially start into its **stationary** state, fetching an initial location before
-    * turning off location services.  Android will be monitoring its **Activity Recognition System** while iOS will create a stationary geofence around
-    * the current location.
-    *
-    * __⚠️ Note:__
-    * If you've configured a {@link AppConfig.schedule}, this method will override that schedule and engage tracking immediately.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.start().then((state) => {
-    *   console.log("[start] success - ", state);
-    * });
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - {@link stop}
-    * - {@link startGeofences}
-    * - 📘 [Philosophy of Operation](github:wiki/Philosophy-of-Operation)
-    */
     start(): Promise<State>;
-    /**
-    * Disable location and geofence monitoring.  This is the SDK's power **OFF** button.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.stop();
-    * ```
-    *
-    * __⚠️ Note:__
-    * If you've configured a {@link AppConfig.schedule}, **`#stop`** will **not** halt the Scheduler.  You must explicitly {@link stopSchedule} as well:
-    *
-    * @example
-    * ```typescript
-    * // Later when you want to stop the Scheduler (eg: user logout)
-    * BackgroundGeolocation.stopSchedule();
-    * ```
-    */
     stop(): Promise<State>;
-    /**
-    * Manually toggles the SDK's **motion state** between **stationary** and **moving**.
-    *
-    * When provided a value of  **`true`**, the plugin will engage location-services and begin aggressively tracking the device's location *immediately*,
-    * bypassing stationary monitoring.
-    *
-    * If you were making a "Jogging" application, this would be your **`[Start Workout]`** button to immediately begin location-tracking.  Send **`false`**
-    * to turn **off** location-services and return the plugin to the **stationary** state.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.changePace(true);  // <-- Location-services ON ("moving" state)
-    * BackgroundGeolocation.changePace(false); // <-- Location-services OFF ("stationary" state)
-    * ```
-    */
     changePace(isMoving: boolean): Promise<State>;
-    /**
-    * Engages the geofences-only {@link State.trackingMode}.
-    *
-    * In this mode, no active location-tracking will occur &mdash; only geofences will be monitored.  To stop monitoring "geofences" {@link TrackingMode},
-    * simply use the usual {@link stop} method.
-    *
-    * @example
-    * ```typescript
-    * // Add a geofence.
-    * BackgroundGeolocation.addGeofence({
-    *   notifyOnExit: true,
-    *   radius: 200,
-    *   identifier: "ZONE_OF_INTEREST",
-    *   latitude: 37.234232,
-    *   longitude: 42.234234
-    * });
-    *
-    * // Listen to geofence events.
-    * BackgroundGeolocation.onGeofence((event) => {
-    *   console.log("[onGeofence] -  ", event);
-    * });
-    *
-    * // Configure the plugin
-    * BackgroundGeolocation.ready({
-    *   url: "http://my.server.com",
-    *   autoSync: true
-    * }).then(((state) => {
-    *   // Start monitoring geofences.
-    *   BackgroundGeolocation.startGeofences();
-    * });
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - {@link stop}
-    * - 📘 {@link Geofence | Geofencing Guide}
-    */
     startGeofences(): Promise<State>;
-    /**
-    * Return the current {@link State} of the plugin, including all {@link Config} parameters.
-    *
-    * @example
-    * ```typescript
-    * let state = await BackgroundGeolocation.getState();
-    * console.log("[state] ", state.enabled, state.trackingMode);
-    * ```
-    */
     getState(): Promise<State>;
-    /**
-    *
-    * Re-configure the SDK's {@link Config} parameters.  This is the method to use when you wish to *change*
-    * the plugin {@link Config} *after* {@link ready} has been executed.
-    *
-    * The supplied {@link Config} will be appended to the current configuration and applied in realtime.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.setConfig({
-    *   desiredAccuracy: Config.DESIRED_ACCURACY_HIGH,
-    *   distanceFilter: 100.0,
-    *   stopOnTerminate: false,
-    *   startOnBoot: true
-    * }).then((state) => {
-    *   console.log("[setConfig] success: ", state);
-    * })
-    * ```
-    */
     setConfig(config: Partial<Config>): Promise<State>;
-    /**
-    * Retrieves the current {@link Location}.
-    *
-    * This method instructs the native code to fetch exactly one location using maximum power & accuracy.  The native code will persist the fetched location to
-    * its SQLite database just as any other location in addition to POSTing to your configured [[Config.url]].
-    * If an error occurs while fetching the location, `catch` will be provided with an [[LocationError]].
-    *
-    *
-    * ### Options
-    *
-    * See {@link CurrentPositionRequest}.
-    *
-    * ### Error Codes
-    *
-    * See {@link LocationError}.
-    *
-    * @example
-    * ```typescript
-    * let location = await BackgroundGeolocation.getCurrentPosition({
-    *   timeout: 30,          // 30 second timeout to fetch location
-    *   maximumAge: 5000,     // Accept the last-known-location if not older than 5000 ms.
-    *   desiredAccuracy: 10,  // Try to fetch a location with an accuracy of `10` meters.
-    *   samples: 3,           // How many location samples to attempt.
-    *   extras: {             // Custom meta-data.
-    *     "route_id": 123
-    *   }
-    * });
-    * ```
-    * __⚠️ Note:__
-    * - While `getCurrentPosition` will receive only **one** {@link Location}, the plugin *does* request **multiple** location samples which will all be provided
-    * to the {@link onLocation} event-listener.  You can detect these samples via {@link Location.sample} `== true`.
-    */
     getCurrentPosition(options?: CurrentPositionRequest): Promise<Location>;
-    /**
-    * Start a stream of continuous location-updates.  The native code will persist the fetched location to its SQLite database
-    * just as any other location (If the SDK is currently [[State.enabled]]) in addition to POSTing to your configured [[Config.url]] (if you've enabled the HTTP features).
-    *
-    * __⚠️ Warning:__
-    * `watchPosition` is **not** recommended for **long term** monitoring in the background &mdash; It's primarily designed for use in the foreground **only**.  You might use it for fast-updates of the user's current position on the map, for example.
-    * The SDK's primary [Philosophy of Operation](github:wiki/Philosophy-of-Operation) **does not require** `watchPosition`.
-    *
-    * __iOS:__
-    * `watchPosition` will continue to run in the background, preventing iOS from suspending your application.  Take care to listen to `suspend` event and call {@link stopWatchPosition} if you don't want your app to keep running in the background, consuming battery.
-    *
-    * @example
-    * ```typescript
-    * onResume() {
-    *   // Start watching position while app in foreground.
-    *   BackgroundGeolocation.watchPosition((location) => {
-    *     console.log("[watchPosition] -", location);
-    *   }, (errorCode) => {
-    *     console.log("[watchPosition] ERROR -", errorCode);
-    *   }, {
-    *     interval: 1000
-    *   })
-    * }
-    *
-    * onSuspend() {
-    *   // Halt watching position when app goes to background.
-    *   BackgroundGeolocation.stopWatchPosition();
-    * }
-    * ```
-    */
     watchPosition(cb: (location: Location) => void, options?: CurrentPositionRequest): Subscription;
-    /**
-    * Stop watch-position updates initiated from {@link watchPosition}.
-    *
-    * @example
-    * ```typescript
-    * onResume() {
-    *   // Start watching position while app in foreground.
-    *   BackgroundGeolocation.watchPosition((location) => {
-    *     console.log("[watchPosition] -", location);
-    *   }, (errorCode) => {
-    *     console.log("[watchPosition] ERROR -", errorCode);
-    *   }, {
-    *    interval: 1000
-    *   })
-    * }
-    *
-    * onSuspend() {
-    *   // Halt watching position when app goes to background.
-    *   BackgroundGeolocation.stopWatchPosition();
-    * }
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - {@link watchPosition}
-    */
     stopWatchPosition?(sub?: Subscription): void;
-    /**
-      * Initialize the `odometer` to `0`.
-      *
-      * @example
-      * ```typescript
-      * BackgroundGeolocation.resetOdometer().then((location) => {
-      *   // This is the location where odometer was set at.
-      *   console.log("[setOdometer] success: ", location);
-      * });
-      * ```
-      *
-      * __⚠️ Note:__
-      * - {@link resetOdometer} will internally perform a {@link getCurrentPosition} in order the record to exact location *where* odometer was set.
-      * - {@link resetOdometer} is the same as {@link setOdometer|`.setOdometer(0)`}
-      */
     resetOdometer(): Promise<number>;
-    /**
-    * Initialize the `odometer` to *any* arbitrary value.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.setOdometer(1234.56).then((location) => {
-    *   // This is the location where odometer was set at.
-    *   console.log("[setOdometer] success: ", location);
-    * });
-    * ```
-    *
-    * __⚠️ Note:__
-    * - {@link setOdometer} will internally perform a {@link getCurrentPosition} in order to record the exact location *where* odometer was set.
-    */
     setOdometer(value: number): Promise<number>;
-    /**
-    * Retrieve the current distance-traveled ("odometer").
-    *
-    * The plugin constantly tracks distance traveled, computing the distance between the current location and last and maintaining the sum.  To fetch the
-    * current **odometer** reading:
-    *
-    * @example
-    * ```typescript
-    * let odometer = await BackgroundGeolocation.getOdometer();
-    * ```
-    *
-    * __ℹ️ See also:__
-    *  - {@link LocationFilter.odometerAccuracyThreshold}.
-    *  - {@link resetOdometer} / {@link setOdometer}.
-    *
-    * __⚠️ Warning:__
-    * - Odometer calculations are dependent upon the accuracy of received locations.  If location accuracy is poor, this will necessarily introduce error into odometer calculations.
-    */
     getOdometer(): Promise<number>;
-    /**
-    * Retrieves the current state of location-provider authorization.
-    *
-    * __ℹ️ See also:__
-    * - You can also *listen* for changes in location-authorization using the event {@link onProviderChange}.
-    *
-    * @example
-    * ```typescript
-    * let providerState = await BackgroundGeolocation.getProviderState();
-    * console.log("- Provider state: ", providerState);
-    * ```
-    */
     getProviderState(): Promise<ProviderChangeEvent>;
-    /**
-    * Manually request location permission from the user with the configured {@link GeoConfig.locationAuthorizationRequest}.
-    *
-    * The method will resolve successful if *either* __`WhenInUse`__ or __`Always`__ is authorized, regardless of {@link GeoConfig.locationAuthorizationRequest}.  Otherwise an error will be returned (eg: user denies location permission).
-    *
-    * If the user has already provided authorization for location-services, the method will resolve successfully immediately.
-    *
-    * If iOS has *already* presented the location authorization dialog and the user has not currently authorized your desired {@link GeoConfig.locationAuthorizationRequest}, the SDK will present an error dialog offering to direct the user to your app's Settings screen.
-    * - To disable this behaviour, see {@link GeoConfig.disableLocationAuthorizationAlert}.
-    * - To customize the text on this dialog, see {@link GeoConfig.locationAuthorizationAlert}.
-    *
-    * __⚠️ Note:__
-    * - The SDK will **already request permission** from the user when you execute {@link start}, {@link startGeofences}, {@link getCurrentPosition}, etc.  You **do not need to explicitly execute this method** with typical use-cases.
-    *
-    * @example
-    * ```typescript
-    * async componentDidMount() {
-    *   // Listen to onProviderChange to be notified when location authorization changes occur.
-    *   BackgroundGeolocation.onProviderChange((event) => {
-    *     console.log('[providerchange]', event);
-    *   });
-    *
-    *   // First ready the plugin with your configuration.
-    *   let state = await BackgroundGeolocation.ready({
-    *     locationAuthorizationRequest: 'Always'
-    *   });
-    *
-    *   // Manually request permission with configured locationAuthorizationRequest.
-    *   try {
-    *     int status = await BackgroundGeolocation.requestPermission();
-    *     console.log('[requestPermission] success: ', status);
-    *   } catch(status) {
-    *     console.warn('[requestPermission] FAILURE: ', status);
-    *   }
-    * }
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - {@link GeoConfig.locationAuthorizationRequest}
-    * - {@link GeoConfig.disableLocationAuthorizationAlert}
-    * - {@link GeoConfig.locationAuthorizationAlert}
-    * - {@link AppConfig.backgroundPermissionRationale} (**Android+*)
-    * - {@link requestTemporaryFullAccuracy} (*iOS 14+*)
-    */
     requestPermission(): Promise<AuthorizationStatus>;
-    /**
-    * __`[iOS 14+]`__ iOS 14 has introduced a new __`[Precise: On]`__ switch on the location authorization dialog allowing users to disable high-accuracy location.
-    *
-    * The method [`requestTemporaryFullAccuracy` (Apple docs)](https://developer.apple.com/documentation/corelocation/cllocationmanager/3600217-requesttemporaryfullaccuracyauth?language=objc) will allow you to present a dialog to the user requesting temporary *full accuracy* for the lifetime of this application run (until terminate).
-    *
-    * ![](https://dl.dropbox.com/s/dj93xpg51vspqk0/ios-14-precise-on.png?dl=1)
-    *
-    * __Configuration &mdash; `Info.plist`__
-    *
-    * In order to use this method, you must configure your __`Info.plist`__ with the `Dictionary` key:
-    * __`Privacy - Location Temporary Usage Description Dictionary`__
-    *
-    * ![](https://dl.dropbox.com/s/52f5lnjc4d9g8w7/ios-14-Privacy-Location-Temporary-Usage-Description-Dictionary.png?dl=1)
-    *
-    * The keys of this `Dictionary` (eg: `Delivery`) are supplied as the first argument to the method.  The `value` will be printed on the dialog shown to the user, explaing the purpose of your request for full accuracy.
-    *
-    * If the dialog fails to be presented, an error will be thrown:
-    * - The Info.plist file doesn’t have an entry for the given purposeKey value.
-    * - The app is already authorized for full accuracy.
-    * - The app is in the background.
-    *
-    * ![](https://dl.dropbox.com/s/8cc0sniv3pvpetl/ios-14-requestTemporaryFullAccuracy.png?dl=1)
-    *
-    * __Note:__ Android and older versions of iOS `< 14` will return [[BackgroundGeolocation.ACCURACY_AUTHORIZATION_FULL]].
-    *
-    * @example
-    *
-    * ```javascript
-    * BackgroundGeolocation.onProviderChange((event) => {
-    *   if (event.accuracyAuthorization == BackgroundGeolocation.ACCURACY_AUTHORIZATION_REDUCED) {
-    *     // Supply "Purpose" key from Info.plist as 1st argument.
-    *     BackgroundGeolocation.requestTemporaryFullAccuracy("Delivery").then((accuracyAuthorization) => {
-    *       if (accuracyAuthorization == BackgroundGeolocation.ACCURACY_AUTHORIZATION_FULL) {
-    *         console.log('[requestTemporaryFullAccuracy] GRANTED: ', accuracyAuthorization);
-    *       } else {
-    *         console.log('[requestTemporaryFullAccuracy] DENIED: ', accuracyAuthorization);
-    *       }
-    *     }).catch((error) => {
-    *       console.warn("[requestTemporaryFullAccuracy] FAILED TO SHOW DIALOG: ", error);
-    *     });
-    *   }
-    * });
-    * ```
-    *
-    * __See also:__
-    * - {@link ProviderChangeEvent.accuracyAuthorization}.
-    * - [What's new in iOS 14 `CoreLocation`](https://levelup.gitconnected.com/whats-new-with-corelocation-in-ios-14-bd28421c95c4)
-    *
-    */
     requestTemporaryFullAccuracy(purposeKey: string): Promise<AccuracyAuthorization>;
-    /**
-    * Adds a {@link Geofence} to be monitored by the native Geofencing API.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.addGeofence({
-    *   identifier: "Home",
-    *   radius: 150,
-    *   latitude: 45.51921926,
-    *   longitude: -73.61678581,
-    *   notifyOnEntry: true,
-    *   notifyOnExit: false,
-    *   notifyOnDwell: true,
-    *   loiteringDelay: 30000,  // 30 seconds
-    *   extras: {               // Optional arbitrary meta-data
-    *     zone_id: 1234
-    *   }
-    * }).then((success) => {
-    *   console.log("[addGeofence] success");
-    * }).catch((error) => {
-    *   console.log("[addGeofence] FAILURE: ", error);
-    * });
-    * ```
-    *
-    * __ℹ️ Note:__
-    * - If a geofence(s) *already* exists with the configured {@link Geofence.identifier}, the previous one(s) will be **deleted** before the new one is inserted.
-    * - When adding *multiple*, it's about **10 times faster** to use {@link addGeofences} instead.
-    * - 📘 {@link Geofence | Geofencing Guide}
-    */
     addGeofence(geofence: Geofence): Promise<boolean>;
-    /**
-    * Adds a list of {@link Geofence} to be monitored by the native Geofencing API.
-    *
-    * @example
-    * ```typescript
-    * let geofences = [{
-    *   identifier: "foo",
-    *   radius: 200,
-    *   latitude: 45.51921926,
-    *   longitude: -73.61678581,
-    *   notifyOnEntry: true
-    * },
-    *   identifier: "bar",
-    *   radius: 200,
-    *   latitude: 45.51921926,
-    *   longitude: -73.61678581,
-    *   notifyOnEntry: true
-    * }];
-    *
-    * BackgroundGeolocation.addGeofences(geofences);
-    * ```
-    *
-    * __ℹ️ Note:__
-    * - If a geofence(s) *already* exists with the configured {@link Geofence.identifier}, the previous one(s) will be **deleted** before the new one is inserted.
-    * - 📘 {@link Geofence | Geofencing Guide}
-    * - {@link addGeofence}
-    *
-    */
     addGeofences(geofences: Geofence[]): Promise<boolean>;
-    /**
-    * Removes a {@link Geofence} having the given {@link Geofence.identifier}.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.removeGeofence("Home").then((success) => {
-    *   console.log("[removeGeofence] success");
-    * }).catch((error) => {
-    *   console.log("[removeGeofence] FAILURE: ", error);
-    * });
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - 📘 {@link Geofence | Geofencing Guide}
-    */
     removeGeofence(identifier: string): Promise<boolean>;
-    /**
-      * Destroy all {@link Geofence}
-      *
-      * @example
-      * ```typescript
-      * BackgroundGeolocation.removeGeofences();
-      * ```
-      *
-      * __ℹ️ See also:__
-      * - 📘 {@link Geofence | Geofencing Guide}
-      */
     removeGeofences(identifiers?: string[]): Promise<boolean>;
-    /**
-    * Fetch a list of all {@link Geofence} in the SDK's database.  If there are no geofences being monitored, you'll receive an empty `Array`.
-    *
-    * @example
-    * ```typescript
-    * let geofences = await BackgroundGeolocation.getGeofences();
-    * console.log("[getGeofences: ", geofences);
-    * ```
-    * __ℹ️ See also:__
-    * - 📘 {@link Geofence | Geofencing Guide}
-    */
     getGeofences(): Promise<Geofence[]>;
-    /**
-    * Fetch a single {@link Geofence} by identifier from the SDK's database.
-    *
-    * @example
-    * ```typescript
-    * let geofence = await BackgroundGeolocation.getGeofence("HOME");
-    * console.log("[getGeofence] ", geofence);
-    * ```
-    *
-    * __ℹ️ See also:__
-    * - 📘 {@link Geofence | Geofencing Guide}
-    */
     getGeofence(identifier: string): Promise<Geofence>;
-    /**
-      * Determine if a particular geofence exists in the SDK's database.
-      *
-      * @example
-      * ```typescript
-      * let exists = await BackgroundGeolocation.geofenceExists("HOME");
-      * console.log("[geofenceExists] ", exists);
-      * ```
-      * __ℹ️ See also:__
-      * - 📘 {@link Geofence | Geofencing Guide}
-      */
     geofenceExists(identifier: string): Promise<boolean>;
-    /**
-    * Initiate the configured {@link AppConfig.schedule}.
-    *
-    * If a {@link AppConfig.schedule} was configured, this method will initiate that schedule.  The plugin will automatically be started or stopped according to
-    * the configured {@link AppConfig.schedule}.
-    *
-    * To halt scheduled tracking, use {@link stopSchedule}.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.startSchedule.then((state) => {
-    *   console.log("[startSchedule] success: ", state);
-    * })
-    * ```
-    * __ℹ️ See also:__
-    *
-    * - {@link AppConfig.schedule}
-    * - {@link startSchedule}
-    */
     startSchedule(): Promise<void>;
-    /**
-    * Halt scheduled tracking.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.stopSchedule.then((state) => {
-    *   console.log("[stopSchedule] success: ", state);
-    * })
-    * ```
-    *
-    * ⚠️ {@link stopSchedule} will **not** execute {@link stop} if the plugin is currently tracking.  You must explicitly execute {@link stop}.
-    *
-    * @example
-    * ```typescript
-    * // Later when you want to stop the Scheduler (eg: user logout)
-    * await BackgroundGeolocation.stopSchedule().then((state) => {
-    *   if (state.enabled) {
-    *     BackgroundGeolocation.stop();
-    *   }
-    * })
-    * ```
-    * __ℹ️ See also:__
-    * - {@link startSchedule}
-    */
     stopSchedule(): Promise<void>;
-    /**
-    * Sets the {@link LoggerConfig.logLevel}.
-    */
     setLogLevel(level: LogLevel): Promise<void>;
     setLogPersist(mode: PersistMode): Promise<void>;
-    /**
-     * Returns the device information.
-     * @example
-     * ```typescript
-     * const deviceInfo = await BackgroundGeolocation.getDeviceInfo();
-     * console.log(deviceInfo);
-     * ```
-     */
     getDeviceInfo(): Promise<DeviceInfo>;
-    /**
-    * Returns the presence of device sensors *accelerometer*, *gyroscope*, *magnetometer*
-    *
-    * These core {@link Sensors} are used by the motion activity-recognition system -- when any of these sensors are missing from a device (particularly on cheap
-    * Android devices), the performance of the motion activity-recognition system will be **severely** degraded and highly inaccurate.
-    *
-    * @example
-    * ```typescript
-    * let sensors = await BackgroundGeolocation.sensors;
-    * console.log(sensors);
-    * ```
-    */
     getSensors(): Promise<Sensors>;
-    /**
-    * Fetches the state of the operating-system's "Power Saving" mode.
-    *
-    * Power Saving mode can throttle certain services in the background, such as HTTP requests or GPS.
-    *
-    * ℹ️ You can listen to changes in the state of "Power Saving" mode from the event {@link onPowerSaveChange}.
-    *
-    * __iOS__
-    *
-    * iOS Power Saving mode can be engaged manually by the user in **Settings -> Battery** or from an automatic OS dialog.
-    *
-    * ![](https://dl.dropboxusercontent.com/s/lz3zl2jg4nzstg3/Screenshot%202017-09-19%2010.34.21.png?dl=1)
-    *
-    * __Android__
-    *
-    * Android Power Saving mode can be engaged manually by the user in **Settings -> Battery -> Battery Saver** or automatically with a user-specified
-    * "threshold" (eg: 15%).
-    *
-    * ![](https://dl.dropboxusercontent.com/s/raz8lagrqayowia/Screenshot%202017-09-19%2010.33.49.png?dl=1)
-    *
-    * @example
-    * ```typescript
-    * let isPowerSaveMode = await BackgroundGeolocation.isPowerSaveMode;
-    * ```
-    */
     isPowerSaveMode(): Promise<boolean>;
-    /**
-    * Remove all records in SDK's SQLite database.
-    *
-    * @example
-    * ```typescript
-    * let success = await BackgroundGeolocation.destroyLocations();
-    * ```
-    */
     destroyLocations(): Promise<void>;
-    /**
-      * Destroy a single location by {@link Location.uuid}
-      *
-      * @example
-      * ```typescript
-      * await BackgroundGeolocation.destroyLocation(location.uuid);
-      * ```
-      */
     destroyLocation(uuid: string): Promise<void>;
-    /**
-     * @hidden
-     * Users can simply call {@link getCurrentPosition} to insert locations on-demand.
-     */
     insertLocation(location: Location): Promise<Location>;
-    /**
-    * Retrieve a List of {@link Location} currently stored in the SDK's SQLite database.
-    *
-    * @example
-    * ```typescript
-    * let locations = await BackgroundGeolocation.getLocations();
-    * ```
-    */
     getLocations(): Promise<Array<Object>>;
-    /**
-    * Retrieve the count of all locations current stored in the SDK's SQLite database.
-    *
-    * @example
-    * ```typescript
-    * let count = await BackgroundGeolocation.getCount();
-    * ```
-    */
     getCount(): Promise<number>;
-    /**
-    * Manually execute upload to configured {@link HttpConfig.url} of all {@link Location} records currently stored in the SDK's SQLite database.
-    *
-    * If the plugin is configured for HTTP with an {@link HttpConfig.url} and {@link HttpConfig.autoSync} `false`, the {@link sync} method will initiate POSTing the locations
-    * currently stored in the native SQLite database to your configured {@link HttpConfig.url}.  When your HTTP server returns a response of `200 OK`, that record(s)
-    * in the database will be DELETED.
-    *
-    * If you configured {@link HttpConfig.batchSync} `true`, all the locations will be sent to your server in a single HTTP POST request, otherwise the plugin will
-    * execute an HTTP post for **each** {@link Location} in the database (REST-style).  Your callback will be executed and provided with a `List` of all the
-    * locations from the SQLite database.  If you configured the plugin for HTTP (by configuring a {@link HttpConfig.url}), your callback will be executed after all
-    * the HTTP request(s) have completed.  If the plugin failed to sync to your server (possibly because of no network connection), the failure callback will
-    * be called with an error message.  If you are **not** using the HTTP features, {@link sync} will delete all records from its SQLite database.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.sync((records) => {
-    *   console.log("[sync] success: ", records);
-    * }).catch((error) => {
-    *   console.log("[sync] FAILURE: ", error);
-    * });
-    *
-    * ```
-    *  ℹ️ For more information, see the [[HttpEvent | HTTP Guide]]
-    */
     sync(): Promise<Array<Object>>;
-    /**
-    * Sends a signal to OS that you wish to perform a long-running task.
-    *
-    * The OS will keep your running in the background and not suspend it until you signal completion with the {@link stopBackgroundTask} method.  Your callback will be provided with a single parameter `taskId`
-    * which you will send to the {@link stopBackgroundTask} method.
-    *
-    * @example
-    * ```typescript
-    * onLocation(location) {
-    *   console.log("[location] ", location);
-    *
-    *   // Perform some long-running task (eg: HTTP request)
-    *   BackgroundGeolocation.startBackgroundTask().then((taskId) => {
-    *     performLongRunningTask.then(() => {
-    *       // When your long-running task is complete, signal completion of taskId.
-    *       BackgroundGeolocation.stopBackgroundTask(taskId);
-    *     }).catch(error) => {
-    *       // Be sure to catch errors:  never leave you background-task hanging.
-    *       console.error(error);
-    *       BackgroundGeolocation.stopBackgroundTask();
-    *     });
-    *   });
-    * }
-    * ```
-    *
-    * __iOS:__
-    * The iOS implementation uses [beginBackgroundTaskWithExpirationHandler](https://developer.apple.com/documentation/uikit/uiapplication/1623031-beginbackgroundtaskwithexpiratio)
-    *
-    * ⚠️ iOS provides **exactly** 180s of background-running time.  If your long-running task exceeds this time, the plugin has a fail-safe which will
-    * automatically {@link stopBackgroundTask} your **`taskId`** to prevent the OS from force-killing your application.
-    *
-    * Logging of iOS background tasks looks like this:
-    * ```
-    * ✅-[BackgroundTaskManager createBackgroundTask] 1
-    * .
-    * .
-    * .
-    *
-    * ✅-[BackgroundTaskManager stopBackgroundTask:]_block_invoke 1 OF (
-    *     1
-    * )
-    * ```
-    * __Android:__
-    *
-    * The Android implementation launches a [`WorkManager`](https://developer.android.com/topic/libraries/architecture/workmanager) task.
-    *
-    * ⚠️ The Android plugin imposes a limit of **3 minutes** for your background-task before it automatically `FORCE KILL`s it.
-    *
-    *
-    * Logging for Android background-tasks looks like this (when you see an hourglass ⏳ icon, a foreground-service is active)
-    * ```
-    *  I TSLocationManager: [c.t.l.u.BackgroundTaskManager onStartJob] ⏳ startBackgroundTask: 6
-    *  .
-    *  .
-    *  .
-    *  I TSLocationManager: [c.t.l.u.BackgroundTaskManager$Task stop] ⏳ stopBackgroundTask: 6
-    * ```
-    */
     startBackgroundTask(): Promise<number>;
-    /**
-    * Signal completion of {@link startBackgroundTask}
-    *
-    * Sends a signal to the native OS that your long-running task, addressed by `taskId` provided by {@link startBackgroundTask} is complete and the OS may proceed
-    * to suspend your application if applicable.
-    *
-    * @example
-    * ```typescript
-    * BackgroundGeolocation.startBackgroundTask().then((taskId) => {
-    *   // Perform some long-running task (eg: HTTP request)
-    *   performLongRunningTask.then(() => {
-    *     // When your long-running task is complete, signal completion of taskId.
-    *     BackgroundGeolocation.stopBackgroundTask(taskId);
-    *   });
-    * });
-    * ```
-    */
     stopBackgroundTask(taskId: number): Promise<void>;
-    /**
-     * @private
-     * @hidden
-     * __[Android-only]__ Signals completion of an Android headless-task (see [[Config.enableHeadless]])
-     */
     finishHeadlessTask(taskId: string): Promise<number>;
 }
-/**
- * Primary BackgroundGeolocation API
- *
- * __Overview__
- *
- * The `BackgroundGeolocation` interface defines the **complete, strongly-typed API surface**
- * for Transistor Software’s Background Geolocation SDK.
- * This is the main entry-point used by all JavaScript adapters:
- *
- * - React Native (`{{pluginName}}`)
- * - Capacitor
- * - Cordova
- *
- * The API provides:
- *
- * - **Configuration** via a single {@link Config} object composed of modular
- *   sub-configs (`GeoConfig`, `HttpConfig`, `PersistenceConfig`, etc)
- * - **Lifecycle control** (`ready`, `start`, `stop`, `setConfig`, `reset`)
- * - **Location tracking** (motion-based tracking, `getCurrentPosition`,
- *   `watchPosition`)
- * - **Geofencing** (`addGeofence`, `onGeofence`, etc)
- * - **Events subsystem** with fully-typed callbacks (`onLocation`,
- *   `onMotionChange`, `onHttp`, `onProviderChange`, etc)
- * - **Native services** such as background-tasks, authorization workflows,
- *   scheduling, and device-capability checks
- * - **Persistence + HTTP** via an internal SQLite buffer and optional
- *   auto-upload system
- *
- * __Typed Configuration (Compound Config)__
- *
- * Instead of a large “flat” configuration object, the SDK uses a
- * *compound-configuration model*:
- *
- * ```ts
- * import BackgroundGeolocation, {
- *   Config,
- *   GeoConfig,
- *   HttpConfig
- * } from "{{pluginName}}";
- *
- * const config: Config = {
- *   geolocation: {
- *     desiredAccuracy: BackgroundGeolocation.DesiredAccuracy.High,
- *     distanceFilter: 20
- *   },
- *   http: {
- *     url: "https://example.com/locations",
- *     autoSync: true
- *   },
- *   persistence: {
- *     maxDaysToPersist: 7
- *   }
- * };
- *
- * BackgroundGeolocation.ready(config);
- * ```
- *
- * This structure ensures:
- *
- * - **Clear separation of concerns**
- * - **Type-safe configuration**
- * - **Automatic backwards-compatibility** with legacy flat keys
- *
- * __Typed Enum Namespaces__
- *
- * All configuration flags that were previously “magic constants”
- * (e.g., `LOG_LEVEL_VERBOSE`, `DESIRED_ACCURACY_HIGH`) now live in
- * strongly-typed namespaces attached to the default export:
- *
- * - {@link BackgroundGeolocation.LogLevel}
- * - {@link BackgroundGeolocation.DesiredAccuracy}
- * - {@link BackgroundGeolocation.PersistMode}
- * - {@link BackgroundGeolocation.NotificationPriority}
- * - {@link BackgroundGeolocation.Event}
- * - …and more
- *
- * These can also be imported individually:
- *
- * ```ts
- * import BackgroundGeolocation, { LogLevel } from "{{pluginName}}";
- *
- * BackgroundGeolocation.ready({
- *   logger: {
- *     logLevel: LogLevel.Debug
- *   }
- * });
- * ```
- *
- * __Event System__
- *
- * The SDK exposes a robust, typed event API:
- *
- * ```ts
- * BackgroundGeolocation.onLocation((location) => {
- *   console.log("New location:", location);
- * });
- *
- * BackgroundGeolocation.onMotionChange((event) => {
- *   console.log("Device is moving?", event.isMoving);
- * });
- * ```
- *
- * All events return **Subscription** objects which must be removed when no longer
- * needed:
- *
- * ```ts
- * const sub = BackgroundGeolocation.onHttp((e) => { ... });
- * sub.remove();
- * ```
- *
- * __Native Lifecycle Requirements__
- *
- * On both iOS and Android, `BackgroundGeolocation.ready(config)` must be called
- * **exactly once per app launch**, before calling `start()`.
- * The SDK automatically restores its last-known configuration from persistent
- * storage after first install.
- *
- * __Philosophy of Operation__
- *
- * Transistorsoft’s tracking engine is built around:
- *
- * - **Motion-based state transitions** (stationary ↔ moving)
- * - **Aggressive tracking only when moving**
- * - **Energy-efficient passive monitoring when stationary**
- * - **Reliable persistence via SQLite**
- * - **Automatic retries + batching** for HTTP uploads
- *
- * Combined, this enables *battery-efficient*, *high-quality* background tracking
- * across iOS and Android.
- *
- * __Capabilities__
- *
- * - High-frequency tracking while the device is moving
- * - Zero-movement battery preservation
- * - Geofence monitoring at scale (thousands of geofences)
- * - Offline storage + sync when network is restored
- * - Background tasks for long-running operations
- * - Authorization state + system diagnostics
- *
- * __Getting Started__
- *
- * ```ts
- * import BackgroundGeolocation from "{{pluginName}}";
- *
- * const state = await BackgroundGeolocation.ready({
- *   geolocation: { distanceFilter: 10 },
- *   http: { url: "https://example.com/locations", autoSync: true }
- * });
- *
- * if (!state.enabled) {
- *   await BackgroundGeolocation.start();
- * }
- * ```
- *
- * Once `start()` is called, the SDK begins operating according to your
- * configuration and continues running—even in the background—until you call
- * `stop()`.
- *
- * @category Primary API
- */
 export interface BackgroundGeolocation extends BackgroundGeolocationAPI {
-    /**
-     * __LogLevel__
-     * Controls verbosity of the SDK logger.
-     * Used by LoggerConfig.logLevel.
-     * Values range from silent (`Off`) to extremely verbose (`Verbose`).
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   logger: {
-     *     logLevel: BackgroundGeolocation.LogLevel.Verbose
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     LogLevel: typeof import('../../enums/LogLevel').LogLevel;
-    /**
-     * __DesiredAccuracy__
-     * Controls the native location engine’s target accuracy.
-     * Higher accuracy consumes more battery.
-     * Used by GeoConfig.desiredAccuracy.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   geolocation: {
-     *     desiredAccuracy: BackgroundGeolocation.DesiredAccuracy.High
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     DesiredAccuracy: typeof import('../../enums/DesiredAccuracy').DesiredAccuracy;
-    /**
-     * __PersistMode__
-     * Controls which records the SDK persists to SQLite:
-     * locations only, geofences only, both, or none.
-     * Used by PersistenceConfig.persistMode.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   persistence: {
-     *     persistMode: BackgroundGeolocation.PersistMode.All
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     PersistMode: typeof import('../../enums/PersistMode').PersistMode;
-    /**
-     * __AuthorizationStrategy__
-     * Defines how the HTTP service performs authorization.
-     * Includes basic, JWT, and custom strategies.
-     * Used by AuthorizationConfig.strategy.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   authorization: {
-     *     strategy: BackgroundGeolocation.AuthorizationStrategy.Jwt
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     AuthorizationStrategy: typeof import('../../enums/AuthorizationStrategy').AuthorizationStrategy;
-    /**
-     * __LocationFilterPolicy__
-     * Selects the filtering engine policy for noise-reduction and smoothing.
-     * Used by GeoConfig.locationFilter.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   geolocation: {
-     *     filter: {
-     *       policy: BackgroundGeolocation.LocationFilterPolicy.Adjust
-     *     }
-     * });
-     * ```
-     * @readonly
-     */
     LocationFilterPolicy: typeof import('../../enums/LocationFilterPolicy').LocationFilterPolicy;
-    /**
-     * __KalmanProfile__
-     * Selects a preset tuning profile for the Kalman filter used in the
-     * filtering engine (aggressive, moderate, or relaxed smoothing).
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   geolocation: {
-     *     kalmanProfile: BackgroundGeolocation.KalmanProfile.Aggressive
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     KalmanProfile: typeof import('../../enums/KalmanProfile').KalmanProfile;
-    /**
-     * __HttpMethod__
-     * Defines the HTTP method used for uploads (POST, PUT, etc).
-     * Used by HttpConfig.method.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   http: {
-     *     method: BackgroundGeolocation.HttpMethod.Post
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     HttpMethod: typeof import('../../enums/HttpMethod').HttpMethod;
-    /**
-     * __TriggerActivity__
-     * Defines which physical motion activities can trigger motion-detection
-     * transitions (still → moving).
-     * Used by ActivityConfig.triggerActivities.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   activity: {
-     *     triggerActivities: [
-     *       BackgroundGeolocation.TriggerActivity.InVehicle
-     *     ]
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     TriggerActivity: typeof import('../../enums/TriggerActivity').TriggerActivity;
-    /**
-     * __NotificationPriority__
-     * Controls Android foreground-service notification priority and icon
-     * placement (top, bottom, hidden).
-     * Used by NotificationConfig.priority.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   notification: {
-     *     priority: BackgroundGeolocation.NotificationPriority.High
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     NotificationPriority: typeof import('../../enums/NotificationPriority').NotificationPriority;
-    /**
-     * __Event__
-     * Enumerates all event names emitted by the SDK (location, geofence,
-     * motionchange, heartbeat, etc).
-     *
-     * @readonly
-     */
     Event: typeof import('../../enums/Event').Event;
-    /**
-     * __LocationRequest__
-     * Defines the type of permission request made to iOS (Always, WhenInUse,
-     * or Any).
-     * Used by GeoConfig.locationAuthorizationRequest.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.ready({
-     *   geolocation: {
-     *     locationAuthorizationRequest: BackgroundGeolocation.LocationRequest.Always
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     LocationRequest: typeof import('../../enums/LocationRequest').LocationRequest;
-    /**
-     * __AccuracyAuthorization__
-     * iOS 14+: Indicates whether the user granted full or reduced accuracy.
-     * Used by ProviderChangeEvent.accuracyAuthorization and
-     * requestTemporaryFullAccuracy.
-     *
-     * @example
-     * ```ts
-     * BackgroundGeolocation.onProviderChange((event) => {
-     *   if (event.accuracyAuthorization ===
-     *       BackgroundGeolocation.AccuracyAuthorization.Reduced) {
-     *     // Handle reduced-accuracy case
-     *   }
-     * });
-     * ```
-     * @readonly
-     */
     AccuracyAuthorization: typeof import('../../enums/AccuracyAuthorization').AccuracyAuthorization;
-    /**
-     * __AuthorizationStatus__
-     * Represents OS-level authorization state for location-services
-     * (Denied, Restricted, Always, WhenInUse).
-     * Returned from requestPermission() and onProviderChange.
-     *
-     * @example
-     * ```ts
-     * const status = await BackgroundGeolocation.requestPermission();
-     * if (status === BackgroundGeolocation.AuthorizationStatus.Always) {
-     *   // Good to start tracking
-     * }
-     * ```
-     * @readonly
-     */
     AuthorizationStatus: typeof import('../../enums/AuthorizationStatus').AuthorizationStatus;
-    /**
-     * __ActivityType__
-     * iOS-only: Specifies the type of user activity (AutomotiveNavigation,
-     * Fitness, OtherNavigation, etc).
-     * Used by {@link GeoConfig.activityType}.
-     */
     ActivityType: typeof import('../../enums/ActivityType').ActivityType;
 }