@transistorsoft/capacitor-background-geolocation 4.9.4 → 4.10.0

package/dist/declarations/ConnectivityChangeEvent.d.ts

@@ -1,18 +0,0 @@
-declare module "@transistorsoft/capacitor-background-geolocation" {
-	/**
-	* The event-object provided to [[BackgroundGeolocation.onConnectivityChange]]
-	*
-	* @example
-	* ```typescript
-	* BackgroundGeolocation.onConnectivityChange(connectivityChangeEvent => {
-	*   console.log("[connectivitychange] ", connectivityChangeEvent.connected);
-	* });
-	* ```
-	*/
-	interface ConnectivityChangeEvent {
-	  /**
-	  * `true` when the device has access to a network connection.
-	  */
-	  connected: boolean;
-	}
-}

package/dist/declarations/CurrentPositionRequest.d.ts

@@ -1,45 +0,0 @@
-declare module "@transistorsoft/capacitor-background-geolocation" {
-  /**
-  * Options provided to [[getCurrentPosition]].
-  *
-  * @example
-  * ```typescript
-  * let location = await BackgroundGeolocation.getCurrentPosition({
-  *   timeout: 30,          // 30 second timeout to fetch location
-  *   persist: true,        // Defaults to state.enabled
-  *   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
-  *   }
-  * });
-  * ```
-  */
-  interface CurrentPositionRequest {
-    /**
-    * Sets the maximum number of location-samples to fetch before returning the best possible location to your `callback`.  Default is `3`.  Only the final Location will be persisted.
-    */
-    samples?: number;
-    /**
-    * Sets the desired accuracy of location you're attempting to fetch. When a location having `accuracy <= desiredAccuracy` is retrieved, the plugin will stop sampling and immediately return that location. Defaults to your configured [[Config.stationaryRadius]].
-    */
-    desiredAccuracy?: number;
-    /**
-    * Location-timeout in `seconds`.  Default: `30`.  If the timeout expires before a [[Location]] is retrieved, a [[LocationError]] will fire.
-    */
-    timeout?: number;
-    /**
-    * Defaults to `true` when plugin is `enabled`; `false`, otherwise.  Set `false` to disable persisting the retrieved Location in the plugin's SQLite database.
-    */
-    persist?: boolean;
-    /**
-    * Accept the last-recorded-location if no older than supplied value in `milliseconds`.  Default is `0`.
-    */
-    maximumAge?: number;
-    /**
-    * Optional meta-data to attach to the location. These `extras` will be merged to the configured [[Config.extras]] and persisted / POSTed to your server (if you've configured a [[Config.url]].
-    */
-    extras?: Extras;
-  }
-}

package/dist/declarations/DeviceInfo.d.ts

@@ -1,33 +0,0 @@
-declare module "@transistorsoft/capacitor-background-geolocation" {
-  /**
-  * Simple device information, much simpler than other 3rd party libraries.
-  *
-  * @example
-  * ```typescript
-  * let deviceInfo = await BackgroundGeolocation.getDeviceInfo();
-  * ```
-  */
-  interface DeviceInfo {
-  	/**
-  	* Device model
-  	*/
-    model:string;
-    /**
-    * Device manufacturer.
-    */
-    manufacturer:string;
-    /**
-    * OS Version code.
-    */
-    version:string;
-    /**
-    * Platform:  iOS or Android
-    */
-    platform:string;
-    /**
-    * Development framework (react-native or cordova)
-    */
-    framework:string;
-  }
-}
-

package/dist/declarations/DeviceSettings.d.ts

@@ -1,223 +0,0 @@
-declare module "@transistorsoft/capacitor-background-geolocation" {
-	/**
-	* An object for redirecting a User to an Android device's settings screen from a [DeviceSettings] request.
-	*
-	* This object contains meta-data about the device ([[manufacturer]\], [[model]], [[version]]) in addition to a flag [seen] to let you know if you've
-	* already shown some particular screen to the user.  [[lastSeenAt]] lets you know the `DateTime` you last showed a particular screen to the user.
-	*
-	*/
-	interface DeviceSettingsRequest {
-		/**
-		* Device manufacturer.
-		*/
-		manufacturer: string;
-		/**
-		* Device model
-		*/
-		model: string;
-		/**
-		* OS version
-		*/
-		version: string;
-		/**
-		* Flag showing whether you've already shown this screen to the user.
-		*/
-		seen: boolean;
-		/**
-		* The [DateTime] you last showed this screen to the user.
-		*/
-		lastSeenAt: Date;
-		/**
-		* The settings screen to be shown.
-	  *
-	  * ⚠️ This property is set automatically.
-	  */
-		action: string;
-	}
-
-	/**
-	* Device Settings API.
-	*
-	* Provides an API to show Android & vendor-specific Battery / Power Management settings screens that can affect performance of the Background Geolocation SDK on various devices.
-	*
-	* The site [Don't Kill My App](https://dontkillmyapp.com/) provides a comprehensive list of poor Android vendors which throttle background-services that this plugin relies upon.
-	*
-	* This `DeviceSettings` API is an attempt to provide resources to direct the user to the appropriate vendor-specific settings screen to resolve issues with background operation.
-	*
-	* ![](https://dl.dropboxusercontent.com/s/u7ljngfecxvibyh/huawei-settings-battery-launch.jpg?dl=1)
-	* ![](https://dl.dropboxusercontent.com/s/hd6yxw58hgc7ef4/android-settings-battery-optimization.jpg?dl=1)
-	*
-	* @example
-	* ```typescript
-	* // Is Android device ignoring battery optimizations?
-	* let isIgnoring = await BackgroundGeolocation.deviceSettings.isIgnoringBatteryOptimizations();
-	* if (!isIgnoring) {
-  *   BackgroundGeolocation.deviceSettings.showIgnoreBatteryOptimizations().then((request:DeviceSettingsRequest) => {
-  *     console.log(`- Screen seen? ${request.seen} ${request.lastSeenAt}`);
-  *     console.log(`- Device: ${request.manufacturer} ${request.model} ${request.version}`);
-  *
-  *     // If we've already shown this screen to the user, we don't want to annoy them.
-  *     if (request.seen) {
-  *       return;
-  *     }
-  *
-  *     // It's your responsibility to instruct the user what exactly
-  *     // to do here, perhaps with a Confirm Dialog:
-  *     showMyConfirmDialog({
-  *       title: "Settings request",
-  *       text: "Please disable battery optimizations for your device"
-  *     }).then((confirmed) => {
-  *       if (confirmed) {
-  *         // User clicked [Confirm] button.  Execute the redirect to settings screen:
-  *         BackgroundGeolocation.deviceSettings.show(request);
-  *       }
-  *     });
-  *   }).catch((error) => {
-  *     // Depending on Manufacturer/Model/OS Version, a Device may not implement
-  *     // a particular Settings screen.
-  *     console.warn(error);
-  *   });
-  * }
-	*
-	* ```
-	*/
-	interface DeviceSettings {
-		/**
-		* Returns `true` if device is ignoring battery optimizations for your app.
-	  *
-	  * In most cases, the Background Geolocation SDK **will perform normally** with battery optimizations.
-	  *
-	  * ![](https://dl.dropboxusercontent.com/s/hd6yxw58hgc7ef4/android-settings-battery-optimization.jpg?dl=1)
-	  *
-	  * @example
-	  * ```typescript
-	  * let isIgnoring = await BackgroundGeolocation.deviceSettings.isIgnoringBatteryOptimizations();
-	  * ```
-	  */
-	  isIgnoringBatteryOptimizations():Promise<boolean>;
-	  /**
-	  * Shows the Android *Ignore Battery Optimizations* settings screen.
-	  *
-	  * **Note:**  In most cases, the plugin **will perform normally** with battery optimizations.  You should only instruct the user to *Ignore Battery Optimizations* for your app as a last resort to resolve issues with background operation.
-	  *
-	  * ![](https://dl.dropboxusercontent.com/s/hd6yxw58hgc7ef4/android-settings-battery-optimization.jpg?dl=1)
-	  *
-	  * **WARNING:**  Ignoring battery optimizations *will* cause your app to consume **much** more power.
-	  *
-	  * `showIgnoreBatteryOptimizations` does **not** immediately redirect to the desired Device settings screen.  Instead, it first returns a [[DeviceSettingsRequest]], containing
-	  * meta-data about the device (`manufacturer`, `model`, `version`), in addition to a flags `seen` and `lastSeenAt`, letting you know if and when you've already shown this screen to the user.
-	  *
-	  *
-	  * In your success-callback, it's completely **up to you** to instruct the user what exactly to do on that screen.
-	  *
-	  * Based upon the manufacturer/model/os, a Device may not have this particular Settings screen implemented.  In this case, `catch` will fire.
-	  *
-	  * @example
-	  * ```typescript
-	  * // Is Android device ignoring battery optimizations?
-	  * let isIgnoring = await BackgroundGeolocation.deviceSettings.isIgnoringBatteryOptimizations();
-		* if (!isIgnoring) {
-	  *   BackgroundGeolocation.deviceSettings.showIgnoreBatteryOptimizations().then((request:DeviceSettingsRequest) => {
-	  *     console.log(`- Screen seen? ${request.seen} ${request.lastSeenAt}`);
-	  *     console.log(`- Device: ${request.manufacturer} ${request.model} ${request.version}`);
-	  *
-	  *     // If we've already shown this screen to the user, we don't want to annoy them.
-	  *     if (request.seen) {
-	  *       return;
-	  *     }
-	  *
-	  *     // It's your responsibility to instruct the user what exactly
-	  *     // to do here, perhaps with a Confirm Dialog:
-	  *     showMyConfirmDialog({
-	  *       title: "Settings request",
-	  *       text: "Please disable battery optimizations for your device"
-	  *     }).then((confirmed) => {
-	  *       if (confirmed) {
-	  *         // User clicked [Confirm] button.  Execute the redirect to settings screen:
-	  *         BackgroundGeolocation.deviceSettings.show(request);
-	  *       }
-	  *     });
-	  *   }).catch((error) => {
-	  *     // Depending on Manufacturer/Model/OS Version, a Device may not implement
-	  *     // a particular Settings screen.
-	  *     console.warn(error);
-	  *   });
-	  * }
-	  * ```
-	  *
-	  */
-	  showIgnoreBatteryOptimizations():Promise<DeviceSettingsRequest>;
-	  /**
-	  * Shows a vendor-specific "Power Management" screen.
-	  *
-	  * For example, a *Huawei* device will show the *Battery->Launch* screen:
-	  *
-	  * ![](https://dl.dropboxusercontent.com/s/u7ljngfecxvibyh/huawei-settings-battery-launch.jpg?dl=1)
-	  * ![](https://dl.dropboxusercontent.com/s/cce6jxuvxmecv2z/huawei-settings-battery-launch-apply.jpg?dl=1)
-	  *
-	  * The site [Don't Kill My App](https://dontkillmyapp.com/) provides a comprehensive list of poor Android vendors which throttle background-services that this plugin relies upon.
-	  *
-	  * `showPowerManager` does **not** immediately redirect to the desired Device settings screen.  Instead, it first returns a [[DeviceSettingsRequest]], containing
-	  * meta-data about the device (`manufacturer`, `model`, `version`), in addition to a flags `seen` and `lastSeenAt`, letting you know if and when you've already shown this screen to the user.
-	  *
-	  * Unfortunately, there's no possible way to determine if the user *actually* performs the desired action to "white list" your app on the shown settings-screen.
-	  * For this reason, you'll have to evaluate the provided properties [[DeviceSettingsRequest.seen]] &amp; [[DeviceSettingsRequest.lastSeenAt]] and determine for yourself whether to [[DeviceSettings.show]] this screen.
-		*
-	  * In your success-callback, it's completely **up to you** to instruct the user what exactly to do on that screen, based upon the provided [[DeviceSettingsRequest]] properties `manufacturer`, `model` and `version`.
-	  *
-	  * **Note:**  Based upon the `manufacturer` / `model` / OS `version`, a Device **may not have** a particular Settings screen implemented (eg: Google Pixel).  In this case, the `Promise` will fire an exception.
-	  *
-	  * ## Example
-	  *
-	  * ```typescript
-	  * BackgroundGeolocation.deviceSettings.showPowerManager().then((request:DeviceSettingsRequest) => {
-    *   console.log(`- Screen seen? ${request.seen} ${request.lastSeenAt}`);
-    *   console.log(`- Device: ${request.manufacturer} ${request.model} ${request.version}`);
-    *
-    *   // If we've already shown this screen to the user, we don't want to annoy them.
-    *   if (request.seen) {
-    *     return;
-    *   }
-    *   // It's your responsibility to instruct the user what exactly
-    *   // to do here, perhaps with a Confirm Dialog:
-    *   showMyConfirmDialog({
-    *     title: "Device Power Management",
-    *     text: "Please white-list the app in your Device's Power Management settings by clicking this then selecting that."
-    *   }).then((confirmed) => {
-    *     if (confirmed) {
-    *       // User clicked [Confirm] button.  Execute the redirect to settings screen:
-    *       BackgroundGeolocation.deviceSettings.show(request);
-    *     }
-    *   });
-    * }).catch((error) => {
-    *   // Depending on Manufacturer/Model/OS Version, a Device may not implement
-    *   // a particular Settings screen.
-    *   console.log(error);
-    * });
-	  * ```
-	  *
-	  * ## Vendor Settings Screens
-	  *
-	  * The following Android Settings screen will be shown depending on Vendor / OS version:
-	  *
-	  * | Vendor                               | Settings Activity Name                                                 |
-	  * |--------------------------------------|------------------------------------------------------------------------|
-	  * | LeEco                                | `AutobootManageActivity`                                               |
-	  * | Huawei                               | `StartupAppControlActivity`,`StartupAppControlActivity` (depends on OS version) |
-	  * | Color OS                             | `StartupAppListActivity`                                               |
-	  * | OPPO                                 | `StartupAppListActivity`                                               |
-	  * | Vivo                                 | `BgStartUpManagerActivity`,`AddWhiteListActivity`,`BgStartUpManager` (depends on OS version)|
-	  * | Samsung                              | `BatteryActivity`                                                      |
-	  * | HTC                                  | `LandingPageActivity`                                                  |
-	  * | Asus                                 | `AutobootManageActivity`                                               |
-	  * | LeEco                                | `mobilemanager.MainActivity`                                           |
-	  *
-	  */
-	  showPowerManager():Promise<DeviceSettingsRequest>;
-
-	  /**
-	  * This method is designed to be executed from a [[showPowerManager]] or [[showIgnoreBatteryOptimizations]] callback.
-	  */
-	  show(request:DeviceSettingsRequest):Promise<boolean>;
-	}
-}

package/dist/declarations/Geofence.d.ts

@@ -1,255 +0,0 @@
-declare module "@transistorsoft/capacitor-background-geolocation" {
-  /**
-  * The Background Geolocation SDK implements the native iOS and Android Geofencing APIs.
-  *
-  * __ℹ️ Note:__
-  * - Native iOS & Android API support only *circular* geofences.
-  * - The minimum reliable [[radius]] is `200` meters.
-  * - Geofence monitoring *requires* the user authorize [[locationAuthorizationRequest]] **`Always`** — **`When in Use`** will **not** work.
-  *
-  * ## Adding Geofences
-  *
-  * Adding a single geofence with [[addGeofence]].
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.addGeofence({
-  *   identifier: "Home",
-  *   radius: 200,
-  *   latitude: 45.51921926,
-  *   longitude: -73.61678581,
-  *   notifyOnEntry: true,
-  *   notifyOnExit: true,
-  *   extras: {
-  *     route_id: 1234
-  *   }
-  * }).then((success) => {
-  *   console.log("[addGeofence] success");
-  * }).catch((error) => {
-  *   console.log("[addGeofence] FAILURE: ", error);
-  * });
-  * ```
-  *
-  * Adding multiple geofences with [[addGeofences]].
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.addGeofences([{
-  *   identifier: "Home",
-  *   radius: 200,
-  *   latitude: 45.51921926,
-  *   longitude: -73.61678581,
-  *   notifyOnEntry: true,
-  * }, {
-  *   identifier: "Work",
-  *   radius: 200,
-  *   latitude: 45.61921927,
-  *   longitude: -73.71678582,
-  *   notifyOnEntry: true
-  * }]).then((success) => {
-  *   console.log("[addGeofences] success");
-  * }).catch((error) => {
-  *   console.log("[addGeofences] FAILURE: ", error);
-  * });
-  * ```
-  *
-  * __ℹ️ Note:__ Adding a geofence having an [[identifier]] which already exists within the SDK geofence database will cause the previous record to be destroyed and the new one inserted.
-  *
-  * ---------------------------------------------------------------------------------------------------
-  *
-  * ## Listening for Geofence Events
-  *
-  * Listen to geofence events with [[BackgroundGeolocation.onGeofence]].
-  *
-  * @example
-  * ```typescript
-  * // Listen for geofence events.
-  * BackgroundGeolocation.onGeofence(geofence => {
-  *   console.log("[geofence] ", geofence.identifier, geofence.action);
-  * });
-  * ```
-  *
-  * ---------------------------------------------------------------------------------------------------
-  *
-  * ## Infinite Geofencing
-  *
-  * The Background Geolocation SDK contains unique and 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 SDK 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 ([[geofenceProximityRadius]]), activating only those geofences closest to the device's current location (according the limit imposed by the corresponding platform).
-  *
-  * - When the device is determined to be moving, the plugin periodically queries for geofences within the [[geofenceProximityRadius]] (eg. every minute) using the latest recorded location.  This geospatial query is **very fast**, even with tens-of-thousands geofences in the database.
-  * - The SDK **enforces** a *minimum* [[geofenceProximityRadius]] of `1000` meters.
-  * - In the following image, the *green* geofences within [[geofenceProximityRadius]] are *actively* monitored.  The *grey* geofences outside [[geofenceProximityRadius]] still exist within the SDK's database but are *not* actively being monitored.
-  *
-  * ![](https://dl.dropboxusercontent.com/s/7sggka4vcbrokwt/geofenceProximityRadius_iphone6_spacegrey_portrait.png?dl=1)
-  *
-  * ---------------------------------------------------------------------------------------------------
-  *
-  * ## Listening for changes in the actively-monitored set-of-geofences.
-  *
-  * As the SDK periodically queries for geofences within the [[geofenceProximityRadius]], you can listen for changes in the actively-monitored geofences using the event [[onGeofencesChange]].  This event will let you know those geofences which have *begun* to be *actively monitored* ([[GeofencesChangeEvent.on]]) in addition to those which just *ceased* to be actively monitored ([[GeofencesChangeEvent.off]]).
-  *
-  * @example
-  * ```typescript
-  * 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);
-  *   }
-  * });
-  * ```
-  * ### ⚠️ Note:
-  * - When **all** geofences have been removed, the [[GeofencesChangeEvent]] will provide empty lists for both [[GeofencesChangeEvent.on]] & [[GeofencesChangeEvent.off]].
-  *
-  * ---------------------------------------------------------------------------------------------------
-  *
-  * ## Removing Geofences
-  *
-  * Once a geofence has been inserted into the SDK's database using [[addGeofence]] or [[addGeofences]], they will be monitored *forever*.  If you've configured [[stopOnTerminate]] __`false`__ and [[startOnBoot]] __`true`__, geofences will continue to be monitored even if the application is terminated or device rebooted.
-  * To cease monitoring a geofence or *geofences*, you must *remove* them from the SDK's database.
-  *
-  * - Removing a single geofence by [[identifier]] with [[removeGeofence]]:
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.removeGeofence("HOME").then(success => {
-  *   console.log("[removeGeofence] success");
-  * })
-  * ```
-  *
-  * - Removing *all* geofences with [[removeGeofences]]:
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.removeGeofences().then(success => {
-  *   console.log("[removeGeofences] all geofences have been destroyed");
-  * })
-  * ```
-  * ---------------------------------------------------------------------------------------------------
-  *
-  * ## Querying Geofences
-  *
-  * Use the method [[getGeofences]] to retrieve the entire Array of [[Geofence]] stored in the SDK's database.
-  *
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.getGeofences().then(geofences => {
-  *   console.log("[getGeofences] ", geofences);
-  * })
-  * ```
-  *
-  * ---------------------------------------------------------------------------------------------------
-  *
-  * ## Monitoring *only* geofences
-  *
-  * The BackgroundGeolocation SDK allows you to optionally monitor *only* geofences without constant location-tracking.  To engage *geofences-only* mode, use the method [[startGeofences]] instead of [[start]].
-  *
-  * Use option [[Config.geofenceModeHighAccuracy]]:true to improve the responsiveness of geofence events.
-  *
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.onGeofence(geofence => {
-  *   console.log("[geofence] ", geofence);
-  * })
-  *
-  * BackgroundGeolocation.ready({
-  *   url: "http://your.server.com/geofences",
-  *   autoSync: true,
-  *   geofenceModeHighAccuracy: true   // <-- consumes more power; default is false.
-  * }, state => {
-  *   // engage geofences-only mode:
-  *   BackgroundGeolocation.startGeofences();
-  * })
-  * ```
-  *
-  * ## Toggling between tracking-modes [[start]] and [[startGeofences]]
-  *
-  * The SDK can easily be toggled between [[State.trackingMode]] simply by executing the corresponding [[start]] or [[startGeofences]] methods.
-  *
-  * @example
-  * ```typescript
-  * // Listen to geofence events
-  * BackgroundGeolocation.onGeofence(geofence => {
-  *   console.log("[geofence] ", geofence);
-  *   if (geofence.identifier == "DANGER_ZONE") {
-  *     if (geofence.action == "ENTER") {
-  *       // Entering the danger-zone, we want to aggressively track location.
-  *       BackgroundGeolocation.start();
-  *     } else if (geofence.action == "EXIT") {
-  *       // Exiting the danger-zone, we resume geofences-only tracking.
-  *       BackgroundGeolocation.startGeofences();
-  *     }
-  *   }
-  * })
-  *
-  * // Add a geofence.
-  * BackgroundGeolocation.addGeofence({
-  *   identifier: "DANGER_ZONE",
-  *   radius: 1000,
-  *   latitude: 45.51921926,
-  *   longitude: -73.61678581,
-  *   notifyOnEntry: true,
-  *   notifyOnExit: true,
-  * })
-  *
-  * // Ready the plugin.
-  * BackgroundGeolocation.ready({
-  *   desiredAccuracy: BackgroundGeolocation.DESIRED_ACCURACY_HIGH,
-  *   distanceFilter: 10,
-  *   url: "http://your.server.com/locations",
-  *   autoSync: true
-  * }, state => {
-  *   BackgroundGeolocation.startGeofences();
-  * })
-  * ```
-  *
-  */
-  interface Geofence {
-    /**
-    * Unique geofence identifier.
-    */
-    identifier: string;
-    /**
-    * Radius of the circular geofence.
-    *
-    * ⚠️ The minimum reliable `radius` is __`200`__ meters.  Anything less will likely not cause a geofence to trigger.  This is documented by Apple [here](https://developer.apple.com/library/archive/documentation/UserExperience/Conceptual/LocationAwarenessPG/RegionMonitoring/RegionMonitoring.html):
-    * > *"The specific threshold distances are determined by the hardware and the location technologies that are currently available. For example, if WiFi is disabled, region monitoring is significantly less accurate. However, for testing purposes, __you can assume that the minimum distance is approximately 200 meters__*".
-    */
-    radius: number;
-    /**
-    * Latitude of geofence center
-    */
-    latitude: number;
-    /**
-    * Longitude of geofence center.
-    */
-    longitude: number;
-    /**
-    * Set `true` to fire event when device *enters* this geofence.
-    *
-    * __ℹ️ See also:__
-    * - [[Config.geofenceInitialTriggerEntry]]
-    */
-    notifyOnEntry?: boolean;
-    /**
-    * Set `true` to fire event when device *exits* this geofence.
-    */
-    notifyOnExit?: boolean;
-    /**
-    * Set `true` to fire event when device "loiters" within this geofence for [[loiteringDelay]] milliseconds.
-    */
-    notifyOnDwell?: boolean;
-    /**
-    * Minimum time in *milliseconds* the device must "loiter" within this geofence before [[notifyOnDwell]] event fires.
-    */
-    loiteringDelay?: number;
-    /**
-    * Arbitrary key-values appended to the geofence event and posted to your configured [[Config.url]].
-    */
-    extras?: Extras;
-  }
-}

package/dist/declarations/GeofenceEvent.d.ts

@@ -1,30 +0,0 @@
-declare module "@transistorsoft/capacitor-background-geolocation" {
-  /**
-  * The event-object provided to [[BackgroundGeolocation.onGeofence]] when a geofence transition event occurs.
-  *
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.onGeofence(geofenceEvent => {
-  *   console.log("[geofence] ", geofenceEvent.identifier, geofence.action, geofenceEvent.location);
-  * });
-  * ```
-  */
-  interface GeofenceEvent {
-    /**
-    * The identifier of the geofence which fired.
-    */
-    identifier: string;
-    /**
-    * The transition type: `ENTER`, `EXIT`, `DWELL`
-    */
-    action: string;
-    /**
-    * The [[Location]] where the geofence transition occurred.
-    */
-    location: Location;
-    /**
-    * Optional [[Geofence.extras]]
-    */
-    extras?: Extras;
-  }
-}

package/dist/declarations/GeofencesChangeEvent.d.ts

@@ -1,22 +0,0 @@
-/// <reference path="./Geofence.d.ts" />
-///
-declare module "@transistorsoft/capacitor-background-geolocation" {
-  /**
-  * The event-object provided to [[BackgroundGeolocation.onGeofencesChange]].
-  *
-  * The [[GeofencesChangeEvent]] provides only the *changed* geofences, those which just activated or de-activated.
-  *
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.onGeofencesChange(geofencesChangeEvent => {
-  *   console.log("[geofenceschange] ", geofencesChangeEvent.on, geofencesChangeEvent.off);
-  * });
-  * ```
-  * ### ⚠️ Note:
-    * - When **all** geofences have been removed, empty lists will be provided for both [[on]] & [[off]].
-  */
-  interface GeofencesChangeEvent {
-    on: Array<Geofence>;
-    off: Array<string>;
-  }
-}

package/dist/declarations/HeartbeatEvent.d.ts

@@ -1,20 +0,0 @@
-declare module "@transistorsoft/capacitor-background-geolocation" {
-  /**
-  * The event-object provided to [[BackgroundGeolocation.onHeartbeat]]
-  *
-  * @example
-  * ```typescript
-  * BackgroundGeolocation.onHeartbeat(heartbeatEvent => {
-  *   console.log("[heartbeat] ", heartbeatEvent);
-  * });
-  * ```
-  */
-  interface HeartbeatEvent {
-    /**
-    * The last-known location.
-    * ### ⚠️ Note:
-    * - The *heartbeat* event does not actively engage location-services.  If you wish to get the current location in your `callback`, use [[getCurrentPosition]].
-    */
-    location: Location;
-  }
-}