react-native-radar 3.21.0-beta.1 → 3.21.0-beta.2

package/android/src/newarch/java/com/radar/RadarModule.kt

@@ -104,7 +104,7 @@ class RadarModule(reactContext: ReactApplicationContext) :
     override fun initialize(publishableKey: String, fraud: Boolean): Unit {
         val editor = reactApplicationContext.getSharedPreferences("RadarSDK", Context.MODE_PRIVATE).edit()
         editor.putString("x_platform_sdk_type", "ReactNative")
-        editor.putString("x_platform_sdk_version", "3.21.0-beta.1")
+        editor.putString("x_platform_sdk_version", "3.21.0-beta.2")
         editor.apply()
         
         if (fraud) {

package/android/src/oldarch/java/com/radar/RadarModule.java

@@ -98,7 +98,7 @@ public class RadarModule extends ReactContextBaseJavaModule implements Permissio
         this.fraud = fraud;
         SharedPreferences.Editor editor = getReactApplicationContext().getSharedPreferences("RadarSDK", Context.MODE_PRIVATE).edit();
         editor.putString("x_platform_sdk_type", "ReactNative");
-        editor.putString("x_platform_sdk_version", "3.21.0-beta.1");
+        editor.putString("x_platform_sdk_version", "3.21.0-beta.2");
         editor.apply();
         if (fraud) {
             Radar.initialize(getReactApplicationContext(), publishableKey, receiver, Radar.RadarLocationServicesProvider.GOOGLE, fraud);

package/app.plugin.js

@@ -1 +1 @@
-module.exports = require('./lib/commonjs/plugin/withRadar');
+module.exports = require('./plugin/build/withRadar');

package/{lib/typescript/src → dist}/@types/RadarNativeInterface.d.ts

@@ -66,4 +66,3 @@ export interface RadarNativeInterface {
     getHost: () => Promise<string>;
     getPublishableKey: () => Promise<string>;
 }
-//# sourceMappingURL=RadarNativeInterface.d.ts.map

package/dist/@types/RadarNativeInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{lib/typescript/src → dist}/@types/types.d.ts

@@ -509,4 +509,3 @@ export interface RadarTrackingOptionsForegroundService {
     iconColor?: string;
 }
 export type RadarTripStatus = "unknown" | "started" | "approaching" | "arrived" | "expired" | "completed" | "canceled";
-//# sourceMappingURL=types.d.ts.map

package/dist/@types/types.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadarEventVerification = exports.RadarEventConfidence = exports.presetEfficient = exports.presetEfficientAndroid = exports.presetEfficientIOS = exports.presetResponsive = exports.presetResponsiveAndroid = exports.presetResponsiveIOS = exports.presetContinuous = exports.presetContinuousAndroid = exports.presetContinuousIOS = void 0;
+const react_native_1 = require("react-native");
+const platform = react_native_1.Platform.OS;
+exports.presetContinuousIOS = {
+    desiredStoppedUpdateInterval: 30,
+    desiredMovingUpdateInterval: 30,
+    desiredSyncInterval: 20,
+    desiredAccuracy: 'high',
+    stopDuration: 140,
+    stopDistance: 70,
+    replay: 'none',
+    useStoppedGeofence: false,
+    showBlueBar: true,
+    startTrackingAfter: undefined,
+    stopTrackingAfter: undefined,
+    stoppedGeofenceRadius: 0,
+    useMovingGeofence: false,
+    movingGeofenceRadius: 0,
+    syncGeofences: true,
+    useVisits: false,
+    useSignificantLocationChanges: false,
+    beacons: false,
+    sync: 'all',
+};
+exports.presetContinuousAndroid = {
+    desiredStoppedUpdateInterval: 30,
+    fastestStoppedUpdateInterval: 30,
+    desiredMovingUpdateInterval: 30,
+    fastestMovingUpdateInterval: 30,
+    desiredSyncInterval: 20,
+    desiredAccuracy: 'high',
+    stopDuration: 140,
+    stopDistance: 70,
+    replay: 'none',
+    sync: 'all',
+    useStoppedGeofence: false,
+    stoppedGeofenceRadius: 0,
+    useMovingGeofence: false,
+    movingGeofenceRadius: 0,
+    syncGeofences: true,
+    syncGeofencesLimit: 0,
+    foregroundServiceEnabled: true,
+    beacons: false,
+    startTrackingAfter: undefined,
+    stopTrackingAfter: undefined,
+};
+exports.presetContinuous = platform === 'ios' ? exports.presetContinuousIOS : exports.presetContinuousAndroid;
+exports.presetResponsiveIOS = {
+    desiredStoppedUpdateInterval: 0,
+    desiredMovingUpdateInterval: 150,
+    desiredSyncInterval: 20,
+    desiredAccuracy: 'medium',
+    stopDuration: 140,
+    stopDistance: 70,
+    replay: 'stops',
+    useStoppedGeofence: true,
+    showBlueBar: false,
+    startTrackingAfter: undefined,
+    stopTrackingAfter: undefined,
+    stoppedGeofenceRadius: 100,
+    useMovingGeofence: true,
+    movingGeofenceRadius: 100,
+    syncGeofences: true,
+    useVisits: true,
+    useSignificantLocationChanges: true,
+    beacons: false,
+    sync: 'all',
+};
+exports.presetResponsiveAndroid = {
+    desiredStoppedUpdateInterval: 0,
+    fastestStoppedUpdateInterval: 0,
+    desiredMovingUpdateInterval: 150,
+    fastestMovingUpdateInterval: 30,
+    desiredSyncInterval: 20,
+    desiredAccuracy: "medium",
+    stopDuration: 140,
+    stopDistance: 70,
+    replay: 'stops',
+    sync: 'all',
+    useStoppedGeofence: true,
+    stoppedGeofenceRadius: 100,
+    useMovingGeofence: true,
+    movingGeofenceRadius: 100,
+    syncGeofences: true,
+    syncGeofencesLimit: 10,
+    foregroundServiceEnabled: false,
+    beacons: false,
+    startTrackingAfter: undefined,
+    stopTrackingAfter: undefined,
+};
+exports.presetResponsive = platform === 'ios' ? exports.presetResponsiveIOS : exports.presetResponsiveAndroid;
+exports.presetEfficientIOS = {
+    desiredStoppedUpdateInterval: 0,
+    desiredMovingUpdateInterval: 0,
+    desiredSyncInterval: 0,
+    desiredAccuracy: "medium",
+    stopDuration: 0,
+    stopDistance: 0,
+    replay: 'stops',
+    useStoppedGeofence: false,
+    showBlueBar: false,
+    startTrackingAfter: undefined,
+    stopTrackingAfter: undefined,
+    stoppedGeofenceRadius: 0,
+    useMovingGeofence: false,
+    movingGeofenceRadius: 0,
+    syncGeofences: true,
+    useVisits: true,
+    useSignificantLocationChanges: false,
+    beacons: false,
+    sync: 'all',
+};
+exports.presetEfficientAndroid = {
+    desiredStoppedUpdateInterval: 3600,
+    fastestStoppedUpdateInterval: 1200,
+    desiredMovingUpdateInterval: 1200,
+    fastestMovingUpdateInterval: 360,
+    desiredSyncInterval: 140,
+    desiredAccuracy: 'medium',
+    stopDuration: 140,
+    stopDistance: 70,
+    replay: 'stops',
+    sync: 'all',
+    useStoppedGeofence: false,
+    stoppedGeofenceRadius: 0,
+    useMovingGeofence: false,
+    movingGeofenceRadius: 0,
+    syncGeofences: true,
+    syncGeofencesLimit: 10,
+    foregroundServiceEnabled: false,
+    beacons: false,
+    startTrackingAfter: undefined,
+    stopTrackingAfter: undefined,
+};
+exports.presetEfficient = platform === 'ios' ? exports.presetEfficientIOS : exports.presetEfficientAndroid;
+var RadarEventConfidence;
+(function (RadarEventConfidence) {
+    RadarEventConfidence[RadarEventConfidence["none"] = 0] = "none";
+    RadarEventConfidence[RadarEventConfidence["low"] = 1] = "low";
+    RadarEventConfidence[RadarEventConfidence["medium"] = 2] = "medium";
+    RadarEventConfidence[RadarEventConfidence["high"] = 3] = "high";
+})(RadarEventConfidence || (exports.RadarEventConfidence = RadarEventConfidence = {}));
+var RadarEventVerification;
+(function (RadarEventVerification) {
+    RadarEventVerification[RadarEventVerification["accept"] = 1] = "accept";
+    RadarEventVerification[RadarEventVerification["unverify"] = 0] = "unverify";
+    RadarEventVerification[RadarEventVerification["reject"] = -1] = "reject";
+})(RadarEventVerification || (exports.RadarEventVerification = RadarEventVerification = {}));

package/{lib/typescript/src → dist}/NativeRadar.d.ts

@@ -84,4 +84,3 @@ export interface Spec extends TurboModule {
 }
 declare const _default: Spec;
 export default _default;
-//# sourceMappingURL=NativeRadar.d.ts.map

package/dist/NativeRadar.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.getEnforcing('RNRadar');

package/dist/helpers.d.ts

@@ -0,0 +1,2 @@
+export function getHost(): Promise<string>;
+export function getPublishableKey(): Promise<string>;

package/dist/helpers.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublishableKey = exports.getHost = void 0;
+const index_native_1 = __importDefault(require("./index.native"));
+const getHost = () => (index_native_1.default.getHost());
+exports.getHost = getHost;
+const getPublishableKey = () => (index_native_1.default.getPublishableKey());
+exports.getPublishableKey = getPublishableKey;

package/{lib/typescript/src → dist}/index.d.ts

@@ -9,4 +9,3 @@ declare let Map: any;
 export { Map };
 export * from "./@types/types";
 export * from "./@types/RadarNativeInterface";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Map = exports.Autocomplete = exports.RadarRNWeb = void 0;
+const react_native_1 = require("react-native");
+let nativeModule;
+nativeModule = react_native_1.Platform.OS === "web" ? require("./index.web").default : require("./index.native").default;
+exports.default = nativeModule;
+let RadarRNWeb = react_native_1.Platform.OS === "web" ? require("./index.web").default : {};
+exports.RadarRNWeb = RadarRNWeb;
+let Autocomplete = react_native_1.Platform.OS !== "web" ? require("./ui/autocomplete").default : {};
+exports.Autocomplete = Autocomplete;
+let Map = react_native_1.Platform.OS !== "web" ? require("./ui/map").default : {};
+exports.Map = Map;
+__exportStar(require("./@types/types"), exports);
+__exportStar(require("./@types/RadarNativeInterface"), exports);

package/{lib/typescript/src → dist}/index.native.d.ts

@@ -4,4 +4,3 @@ declare global {
 }
 declare const Radar: RadarNativeInterface;
 export default Radar;
-//# sourceMappingURL=index.native.d.ts.map

package/dist/index.native.js

@@ -0,0 +1,411 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+const version_1 = require("./version");
+const isNewArchitecture = global.__turboModuleProxy != null;
+let NativeRadar;
+try {
+    if (isNewArchitecture) {
+        const NativeRadarModule = require('./NativeRadar');
+        NativeRadar = NativeRadarModule.default;
+    }
+    else {
+        NativeRadar = react_native_1.NativeModules.RNRadar;
+    }
+}
+catch (error) {
+    console.error('[Radar] Error loading NativeRadar module:', error);
+    throw error;
+}
+// For old architecture, create a NativeEventEmitter
+const eventEmitter = isNewArchitecture ? null : new react_native_1.NativeEventEmitter(react_native_1.NativeModules.RNRadar);
+const locationEmitter = isNewArchitecture ? NativeRadar === null || NativeRadar === void 0 ? void 0 : NativeRadar.locationEmitter : null;
+const clientLocationEmitter = isNewArchitecture ? NativeRadar === null || NativeRadar === void 0 ? void 0 : NativeRadar.clientLocationEmitter : null;
+const errorEmitter = isNewArchitecture ? NativeRadar === null || NativeRadar === void 0 ? void 0 : NativeRadar.errorEmitter : null;
+const logEmitter = isNewArchitecture ? NativeRadar === null || NativeRadar === void 0 ? void 0 : NativeRadar.logEmitter : null;
+const eventsEmitter = isNewArchitecture ? NativeRadar === null || NativeRadar === void 0 ? void 0 : NativeRadar.eventsEmitter : null;
+const tokenEmitter = isNewArchitecture ? NativeRadar === null || NativeRadar === void 0 ? void 0 : NativeRadar.tokenEmitter : null;
+let locationUpdateSubscription = null;
+let clientLocationUpdateSubscription = null;
+let errorUpdateSubscription = null;
+let logUpdateSubscription = null;
+let eventsUpdateSubscription = null;
+let tokenUpdateSubscription = null;
+const Radar = {
+    initialize: (publishableKey, fraud) => {
+        return NativeRadar.initialize(publishableKey, !!fraud);
+    },
+    trackOnce: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        return NativeRadar.trackOnce(options || null);
+    }),
+    onLocationUpdate: (callback) => {
+        // Clear any existing subscription
+        if (locationUpdateSubscription) {
+            locationUpdateSubscription.remove();
+            locationUpdateSubscription = null;
+        }
+        if (isNewArchitecture && locationEmitter) {
+            locationUpdateSubscription = locationEmitter((event) => {
+                try {
+                    const locationUpdate = {
+                        location: event.location,
+                        user: event.user
+                    };
+                    callback(locationUpdate);
+                }
+                catch (error) {
+                    console.error('[Radar] Error in location update callback:', error);
+                }
+            });
+        }
+        else if (!isNewArchitecture && eventEmitter) {
+            locationUpdateSubscription = eventEmitter.addListener('location', (event) => {
+                try {
+                    const locationUpdate = {
+                        location: event.location,
+                        user: event.user
+                    };
+                    callback(locationUpdate);
+                }
+                catch (error) {
+                    console.error('[Radar] Error in location update callback:', error);
+                }
+            });
+        }
+        else {
+            console.warn('[Radar] No event emitter available for location updates');
+        }
+    },
+    clearLocationUpdate: () => {
+        if (locationUpdateSubscription) {
+            locationUpdateSubscription.remove();
+            locationUpdateSubscription = null;
+        }
+    },
+    onClientLocationUpdate: (callback) => {
+        if (clientLocationUpdateSubscription) {
+            clientLocationUpdateSubscription.remove();
+            clientLocationUpdateSubscription = null;
+        }
+        if (isNewArchitecture && clientLocationEmitter) {
+            clientLocationUpdateSubscription = clientLocationEmitter((event) => {
+                try {
+                    const clientLocationUpdate = {
+                        location: event.location,
+                        stopped: event.stopped,
+                        source: event.source
+                    };
+                    callback(clientLocationUpdate);
+                }
+                catch (error) {
+                    console.error('[Radar] Error in client location update callback:', error);
+                }
+            });
+        }
+        else if (!isNewArchitecture && eventEmitter) {
+            clientLocationUpdateSubscription = eventEmitter.addListener('clientLocation', (event) => {
+                try {
+                    const clientLocationUpdate = {
+                        location: event.location,
+                        stopped: event.stopped,
+                        source: event.source
+                    };
+                    callback(clientLocationUpdate);
+                }
+                catch (error) {
+                    console.error('[Radar] Error in client location update callback:', error);
+                }
+            });
+        }
+        else {
+            console.warn('[Radar] No event emitter available for client location updates');
+        }
+    },
+    clearClientLocationUpdate: () => {
+        if (clientLocationUpdateSubscription) {
+            clientLocationUpdateSubscription.remove();
+            clientLocationUpdateSubscription = null;
+        }
+    },
+    onError: (callback) => {
+        if (errorUpdateSubscription) {
+            errorUpdateSubscription.remove();
+            errorUpdateSubscription = null;
+        }
+        if (isNewArchitecture && errorEmitter) {
+            errorUpdateSubscription = errorEmitter((event) => {
+                callback(event.status);
+            });
+        }
+        else if (!isNewArchitecture && eventEmitter) {
+            errorUpdateSubscription = eventEmitter.addListener('error', (event) => {
+                callback(event.status);
+            });
+        }
+        else {
+            console.warn('[Radar] No event emitter available for error updates');
+        }
+    },
+    clearError: () => {
+        if (errorUpdateSubscription) {
+            errorUpdateSubscription.remove();
+            errorUpdateSubscription = null;
+        }
+    },
+    onLog: (callback) => {
+        if (logUpdateSubscription) {
+            logUpdateSubscription.remove();
+            logUpdateSubscription = null;
+        }
+        if (isNewArchitecture && logEmitter) {
+            logUpdateSubscription = logEmitter((event) => {
+                callback(event.message);
+            });
+        }
+        else if (!isNewArchitecture && eventEmitter) {
+            logUpdateSubscription = eventEmitter.addListener('log', (event) => {
+                callback(event.message);
+            });
+        }
+        else {
+            console.warn('[Radar] No event emitter available for log updates');
+        }
+    },
+    clearLog: () => {
+        if (logUpdateSubscription) {
+            logUpdateSubscription.remove();
+            logUpdateSubscription = null;
+        }
+    },
+    onEventUpdate: (callback) => {
+        if (eventsUpdateSubscription) {
+            eventsUpdateSubscription.remove();
+            eventsUpdateSubscription = null;
+        }
+        if (isNewArchitecture && eventsEmitter) {
+            eventsUpdateSubscription = eventsEmitter((event) => {
+                try {
+                    const eventUpdate = {
+                        user: event.user,
+                        events: event.events
+                    };
+                    callback(eventUpdate);
+                }
+                catch (error) {
+                    console.error('[Radar] Error in event update callback:', error);
+                }
+            });
+        }
+        else if (!isNewArchitecture && eventEmitter) {
+            eventsUpdateSubscription = eventEmitter.addListener('events', (event) => {
+                try {
+                    const eventUpdate = {
+                        user: event.user,
+                        events: event.events
+                    };
+                    callback(eventUpdate);
+                }
+                catch (error) {
+                    console.error('[Radar] Error in event update callback:', error);
+                }
+            });
+        }
+        else {
+            console.warn('[Radar] No event emitter available for event updates');
+        }
+    },
+    clearEventUpdate: () => {
+        if (eventsUpdateSubscription) {
+            eventsUpdateSubscription.remove();
+            eventsUpdateSubscription = null;
+        }
+    },
+    onTokenUpdate: (callback) => {
+        if (tokenUpdateSubscription) {
+            tokenUpdateSubscription.remove();
+            tokenUpdateSubscription = null;
+        }
+        if (isNewArchitecture && tokenEmitter) {
+            tokenUpdateSubscription = tokenEmitter((event) => {
+                callback(event.token);
+            });
+        }
+        else if (!isNewArchitecture && eventEmitter) {
+            tokenUpdateSubscription = eventEmitter.addListener('token', (event) => {
+                callback(event.token);
+            });
+        }
+        else {
+            console.warn('[Radar] No event emitter available for token updates');
+        }
+    },
+    clearTokenUpdate: () => {
+        if (tokenUpdateSubscription) {
+            tokenUpdateSubscription.remove();
+            tokenUpdateSubscription = null;
+        }
+    },
+    requestPermissions: (background) => {
+        return NativeRadar.requestPermissions(background);
+    },
+    setLogLevel: function (level) {
+        return NativeRadar.setLogLevel(level);
+    },
+    setUserId: function (userId) {
+        return NativeRadar.setUserId(userId);
+    },
+    getUserId: function () {
+        return NativeRadar.getUserId();
+    },
+    setDescription: function (description) {
+        return NativeRadar.setDescription(description);
+    },
+    getDescription: function () {
+        return NativeRadar.getDescription();
+    },
+    setMetadata: function (metadata) {
+        return NativeRadar.setMetadata(metadata);
+    },
+    getMetadata: function () {
+        return NativeRadar.getMetadata();
+    },
+    setAnonymousTrackingEnabled: function (enabled) {
+        return NativeRadar.setAnonymousTrackingEnabled(enabled);
+    },
+    getPermissionsStatus: function () {
+        return NativeRadar.getPermissionsStatus();
+    },
+    getLocation: function (desiredAccuracy) {
+        return NativeRadar.getLocation(desiredAccuracy);
+    },
+    trackVerified: function (options) {
+        return NativeRadar.trackVerified(options);
+    },
+    getVerifiedLocationToken: function () {
+        return NativeRadar.getVerifiedLocationToken();
+    },
+    clearVerifiedLocationToken: function () {
+        return NativeRadar.clearVerifiedLocationToken();
+    },
+    startTrackingEfficient: function () {
+        return NativeRadar.startTrackingEfficient();
+    },
+    startTrackingResponsive: function () {
+        return NativeRadar.startTrackingResponsive();
+    },
+    startTrackingContinuous: function () {
+        return NativeRadar.startTrackingContinuous();
+    },
+    startTrackingCustom: function (options) {
+        return NativeRadar.startTrackingCustom(options);
+    },
+    startTrackingVerified: function (options) {
+        return NativeRadar.startTrackingVerified(options);
+    },
+    isTrackingVerified: function () {
+        return NativeRadar.isTrackingVerified();
+    },
+    setProduct: function (product) {
+        return NativeRadar.setProduct(product);
+    },
+    mockTracking: function (options) {
+        return NativeRadar.mockTracking(options);
+    },
+    stopTracking: function () {
+        return NativeRadar.stopTracking();
+    },
+    stopTrackingVerified: function () {
+        return NativeRadar.stopTrackingVerified();
+    },
+    getTrackingOptions: function () {
+        return NativeRadar.getTrackingOptions();
+    },
+    isUsingRemoteTrackingOptions: function () {
+        return NativeRadar.isUsingRemoteTrackingOptions();
+    },
+    isTracking: function () {
+        return NativeRadar.isTracking();
+    },
+    setForegroundServiceOptions: function (options) {
+        return NativeRadar.setForegroundServiceOptions(options);
+    },
+    setNotificationOptions: function (options) {
+        return NativeRadar.setNotificationOptions(options);
+    },
+    getTripOptions: function () {
+        return NativeRadar.getTripOptions();
+    },
+    startTrip: function (options) {
+        return NativeRadar.startTrip(options);
+    },
+    completeTrip: function () {
+        return NativeRadar.completeTrip();
+    },
+    cancelTrip: function () {
+        return NativeRadar.cancelTrip();
+    },
+    updateTrip: function (options) {
+        return NativeRadar.updateTrip(options);
+    },
+    acceptEvent: function (eventId, verifiedPlaceId) {
+        return NativeRadar.acceptEvent(eventId, verifiedPlaceId);
+    },
+    rejectEvent: function (eventId) {
+        return NativeRadar.rejectEvent(eventId);
+    },
+    getContext: function (location) {
+        return NativeRadar.getContext(location);
+    },
+    searchPlaces: function (options) {
+        return NativeRadar.searchPlaces(options);
+    },
+    searchGeofences: function (options) {
+        return NativeRadar.searchGeofences(options);
+    },
+    autocomplete: function (options) {
+        return NativeRadar.autocomplete(options);
+    },
+    geocode: function (options) {
+        return NativeRadar.geocode(options);
+    },
+    reverseGeocode: function (options) {
+        return NativeRadar.reverseGeocode(options);
+    },
+    ipGeocode: function () {
+        return NativeRadar.ipGeocode();
+    },
+    validateAddress: function (address) {
+        return NativeRadar.validateAddress(address);
+    },
+    getDistance: function (option) {
+        return NativeRadar.getDistance(option);
+    },
+    getMatrix: function (option) {
+        return NativeRadar.getMatrix(option);
+    },
+    logConversion: function (options) {
+        return NativeRadar.logConversion(options);
+    },
+    nativeSdkVersion: function () {
+        return NativeRadar.nativeSdkVersion();
+    },
+    rnSdkVersion: function () {
+        return version_1.VERSION;
+    },
+    getHost: function () {
+        return NativeRadar.getHost();
+    },
+    getPublishableKey: function () {
+        return NativeRadar.getPublishableKey();
+    }
+};
+exports.default = Radar;