clevertap-react-native 3.9.0 → 4.0.0

package/.claude/worktrees/vigilant-davinci/src/index.js

@@ -0,0 +1,1270 @@
+import { DeviceEventEmitter, NativeEventEmitter, NativeModules, Platform } from 'react-native';
+
+const CleverTapReact = require('./NativeCleverTapModule').default;
+const EventEmitter = Platform.select({
+    ios: new NativeEventEmitter(CleverTapReact),
+    android: DeviceEventEmitter
+  });
+// NativeModules.CleverTapReactEventEmitter ? new NativeEventEmitter(CleverTapReact) : DeviceEventEmitter;
+/**
+* Set the CleverTap React-Native library name with current version
+* @param {string} libName - Library name will be "React-Native"
+* @param {int} libVersion - The updated library version. If current version is 1.1.0 then pass as 10100  
+*/
+const libName = 'React-Native';
+const libVersion = 30900;
+CleverTapReact.setLibrary(libName,libVersion);
+
+function defaultCallback(method, err, res) {
+    if (err) {
+        console.log('CleverTap ' + method + ' default callback error', err);
+    } else {
+        console.log('CleverTap ' + method + ' default callback result', res);
+    }
+}
+
+/**
+* Calls a CleverTap method with a default callback if necessary
+* @param {string} method - the CleverTap method name as a string
+* @param {array} args - The method args
+* @param {function(err, res)} callback - callback
+*/
+function callWithCallback(method, args, callback) {
+    if (typeof callback === 'undefined' || callback == null || typeof callback !== 'function') {
+        callback = (err, res) => {
+            defaultCallback(method, err, res);
+        };
+    }
+
+    if (args == null) {
+        args = [];
+    }
+
+    args.push(callback);
+
+    CleverTapReact[method].apply(this, args);
+}
+
+var CleverTap = {
+    CleverTapProfileDidInitialize: CleverTapReact.getConstants().CleverTapProfileDidInitialize,
+    CleverTapProfileSync: CleverTapReact.getConstants().CleverTapProfileSync,
+    CleverTapInAppNotificationDismissed: CleverTapReact.getConstants().CleverTapInAppNotificationDismissed,
+    CleverTapInAppNotificationShowed: CleverTapReact.getConstants().CleverTapInAppNotificationShowed,
+    CleverTapInAppNotificationButtonTapped: CleverTapReact.getConstants().CleverTapInAppNotificationButtonTapped,
+    CleverTapCustomTemplatePresent: CleverTapReact.getConstants().CleverTapCustomTemplatePresent,
+    CleverTapCustomFunctionPresent: CleverTapReact.getConstants().CleverTapCustomFunctionPresent,
+    CleverTapCustomTemplateClose: CleverTapReact.getConstants().CleverTapCustomTemplateClose,
+    FCM: CleverTapReact.getConstants().FCM,
+    CleverTapInboxDidInitialize: CleverTapReact.getConstants().CleverTapInboxDidInitialize,
+    CleverTapInboxMessagesDidUpdate: CleverTapReact.getConstants().CleverTapInboxMessagesDidUpdate,
+    CleverTapInboxMessageButtonTapped: CleverTapReact.getConstants().CleverTapInboxMessageButtonTapped,
+    CleverTapInboxMessageTapped: CleverTapReact.getConstants().CleverTapInboxMessageTapped,
+    CleverTapDisplayUnitsLoaded: CleverTapReact.getConstants().CleverTapDisplayUnitsLoaded,
+    CleverTapFeatureFlagsDidUpdate: CleverTapReact.getConstants().CleverTapFeatureFlagsDidUpdate, // @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+    CleverTapProductConfigDidInitialize: CleverTapReact.getConstants().CleverTapProductConfigDidInitialize, // @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+    CleverTapProductConfigDidFetch: CleverTapReact.getConstants().CleverTapProductConfigDidFetch, // @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+    CleverTapProductConfigDidActivate: CleverTapReact.getConstants().CleverTapProductConfigDidActivate, // @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+    CleverTapPushNotificationClicked: CleverTapReact.getConstants().CleverTapPushNotificationClicked,
+    CleverTapPushPermissionResponseReceived: CleverTapReact.getConstants().CleverTapPushPermissionResponseReceived,
+    CleverTapOnVariablesChanged: CleverTapReact.getConstants().CleverTapOnVariablesChanged,
+    CleverTapOnOneTimeVariablesChanged: CleverTapReact.getConstants().CleverTapOnOneTimeVariablesChanged,
+    CleverTapOnValueChanged: CleverTapReact.getConstants().CleverTapOnValueChanged,
+    CleverTapOnVariablesChangedAndNoDownloadsPending: CleverTapReact.getConstants().CleverTapOnVariablesChangedAndNoDownloadsPending,
+    CleverTapOnceVariablesChangedAndNoDownloadsPending: CleverTapReact.getConstants().CleverTapOnceVariablesChangedAndNoDownloadsPending,
+    CleverTapOnFileValueChanged: CleverTapReact.getConstants().CleverTapOnFileValueChanged,
+
+    /**
+    * Add a CleverTap event listener
+    * supported events are CleverTap.CleverTapProfileDidInitialize, CleverTap.CleverTapProfileSync,CleverTap.CleverTapOnInboxButtonClick
+    * ,CleverTap.CleverTapOnInAppButtonClick,CleverTap.CleverTapOnDisplayUnitsLoaded and CleverTap.CleverTapInAppNotificationDismissed
+    * @param {string} eventName - the CleverTap event name
+    * @param {function(event)} your event handler
+    */
+    addListener: function (eventName, handler) {
+        if (EventEmitter) {
+            EventEmitter.addListener(eventName, handler);
+            CleverTapReact.onEventListenerAdded(eventName);
+        }
+    },
+    addOneTimeListener: function (eventName, handler) {
+        if (EventEmitter) {
+            const subscription = EventEmitter.addListener(eventName, (args) =>
+             {
+              handler(args);
+              subscription.remove();
+              });
+            CleverTapReact.onEventListenerAdded(eventName);
+        }
+    },
+
+    /**
+    * Removes all of the registered listeners for given eventName.
+    *
+    * @param {string} eventName -  name of the event whose registered listeners to remove
+    */
+    removeListener: function (eventName) {
+        if (EventEmitter) {
+            EventEmitter.removeAllListeners(eventName);
+        }
+    },
+
+    /**
+    *  @deprecated - Since version 0.5.0. Use removeListener(eventName) instead
+    *  Remove all event listeners
+    */
+    removeListeners: function () {
+        if (DeviceEventEmitter) {
+            DeviceEventEmitter.removeAllListeners();
+        }
+    },
+
+    /**
+    * If an application is launched from a push notification click, returns the CleverTap deep link included in the push notification
+    * @param {function(err, res)} callback that return the url as string in res or a string error in err
+    */
+    getInitialUrl: function (callback) {
+        callWithCallback('getInitialUrl', null, callback);
+    },
+
+    /**
+    * Call this method to set Locale. If Language is english and country is US the locale format which you can set is en_US
+    * @param {string} locale - the locale string
+    */
+    setLocale: function (locale) {
+        CleverTapReact.setLocale(locale);
+    },
+
+    /**
+    * Registers the application to receive push notifications
+    * only necessary for iOS.
+    */
+    registerForPush: function () {
+        CleverTapReact.registerForPush();
+    },
+
+    /**
+     * Manually set the push token on the CleverTap user profile
+     * @param {string} token - the device token
+     * @param {object} pushType - object with the following keys "type", "prefKey", "className", "messagingSDKClassName";
+     */
+    pushRegistrationToken: function (token, pushType) {
+        console.log(`CleverTap RN | pushRegistrationToken| received : token: '${token}'`)
+        CleverTapReact.pushRegistrationToken(token, pushType);
+    },
+
+    /**
+     * Manually set the push token on the CleverTap user profile
+     * @param {string} token - the fcm device token
+     */
+    setFCMPushToken: function (token) {
+        console.log(`CleverTap RN | setFCMPushToken | received : token: '${token}'`)
+        CleverTapReact.setFCMPushTokenAsString(token);
+    },
+
+    /**
+    * Method to create Notification Channels in Android O
+    * @param {string} channelId - A String for setting the id of the notification channel
+    * @param {string} channelName - A String for setting the name of the notification channel
+    * @param {string} channelDescription - A String for setting the description of the notification channel
+    * @param {int} importance - An Integer value setting the importance of the notifications sent in this channel
+    * @param {boolean} showBadge - A boolean value as to whether this channel shows a badge
+    */
+    createNotificationChannel: function (channelId, channelName, channelDescription, importance, showBadge) {
+        CleverTapReact.createNotificationChannel(channelId, channelName, channelDescription, importance, showBadge);
+    },
+
+    /**
+    * Method to create Notification Channels in Android O
+    * @param {string} channelId - A String for setting the id of the notification channel
+    * @param {string} channelName - A String for setting the name of the notification channel
+    * @param {string} channelDescription - A String for setting the description of the notification channel
+    * @param {int} importance - An Integer value setting the importance of the notifications sent in this channel
+    * @param {boolean} showBadge - A boolean value as to whether this channel shows a badge
+    * @param {string} sound - A String for setting the custom sound of the notification channel
+    */
+    createNotificationChannelWithSound: function (channelId, channelName, channelDescription, importance, showBadge, sound) {
+        CleverTapReact.createNotificationChannelWithSound(channelId, channelName, channelDescription, importance, showBadge, sound);
+    },
+
+    /**
+    * Method to create Notification Channels in Android O
+    * @param {string} channelId - A String for setting the id of the notification channel
+    * @param {string} channelName - A String for setting the name of the notification channel
+    * @param {string} channelDescription - A String for setting the description of the notification channel
+    * @param {int} importance - An Integer value setting the importance of the notifications sent in this channel
+    * @param {string} groupId - A String for setting the notification channel as a part of a notification group
+    * @param {boolean} showBadge - A boolean value as to whether this channel shows a badge
+    */
+    createNotificationChannelWithGroupId: function (channelId, channelName, channelDescription, importance, groupId, showBadge) {
+        CleverTapReact.createNotificationChannelWithGroupId(channelId, channelName, channelDescription, importance, groupId, showBadge);
+    },
+
+    /**
+    * Method to create Notification Channels in Android O
+    * @param {string} channelId - A String for setting the id of the notification channel
+    * @param {string} channelName - A String for setting the name of the notification channel
+    * @param {string} channelDescription - A String for setting the description of the notification channel
+    * @param {int} importance - An Integer value setting the importance of the notifications sent in this channel
+    * @param {string} groupId - A String for setting the notification channel as a part of a notification group
+    * @param {boolean} showBadge - A boolean value as to whether this channel shows a badge
+    * @param {string} sound - A String for setting the custom sound of the notification channel
+    */
+    createNotificationChannelWithGroupIdAndSound: function (channelId, channelName, channelDescription, importance, groupId, showBadge, sound) {
+        CleverTapReact.createNotificationChannelWithGroupIdAndSound(channelId, channelName, channelDescription, importance, groupId, showBadge, sound);
+    },
+
+    /**
+    * Method to create Notification Channel Groups in Android O
+    * @param {string} groupId - A String for setting the id of the notification channel group
+    * @param {string} groupName - A String for setting the name of the notification channel group
+    */
+    createNotificationChannelGroup: function (groupId, groupName) {
+        CleverTapReact.createNotificationChannelGroup(groupId, groupName);
+    },
+
+    /**
+    * Method to delete Notification Channels in Android O
+    * @param {string} channelId - A String for setting the id of the notification channel
+    */
+    deleteNotificationChannel: function (channelId) {
+        CleverTapReact.deleteNotificationChannel(channelId);
+    },
+
+    /**
+    * Method to delete Notification Channel Groups in Android O
+    * @param {string} groupId - A String for setting the id of the notification channel group
+    */
+    deleteNotificationChannelGroup: function (groupId) {
+        CleverTapReact.deleteNotificationChannelGroup(groupId);
+    },
+
+    /**
+    * Method to show the App Inbox
+    * @param {object} extras - key-value data from RemoteMessage.getData().  keys and values are strings
+    */
+    createNotification: function (extras) {
+        CleverTapReact.createNotification(extras);
+    },
+
+    /**
+    * Method to prompt the hard permission dialog directly, if the push primer is not required.
+     * @param {string} showFallbackSettings - If the value is true then SDK shows an alert dialog which routes to app's notification settings page.
+    */
+    promptForPushPermission: function (showFallbackSettings) {
+        CleverTapReact.promptForPushPermission(showFallbackSettings);
+    },
+
+    /**
+    * Method to prompt the push primer for android 13 onwards.
+    * @param {object} value - key-value belongs to the localInApp properties. Refer documentation for details.
+    */
+    promptPushPrimer: function (value) {
+        CleverTapReact.promptPushPrimer(value);
+    },
+
+    /**
+    * Returns true/false based on whether push permission is granted or denied.
+    *
+    * @param {function(err, res)} non-null callback to retrieve the result
+    */
+    isPushPermissionGranted: function (callback) {
+        callWithCallback('isPushPermissionGranted', null, callback);
+    },
+
+    /**
+     * Sets the user's consent for event and profile tracking.
+     *
+     * You must call this method separately for each active user profile,
+     * for example, when switching user profiles using `onUserLogin`.
+     *
+     * Consent Scenarios:
+     *
+     * 1. **Complete Opt-Out**  
+     *    `userOptOut = true`, `allowSystemEvents = false`  
+     *    → No events (custom or system) are saved locally or remotely. Maximum privacy.
+     *
+     * 2. **Full Opt-In**  
+     *    `userOptOut = false`, `allowSystemEvents = true`  
+     *    → All events (custom and system) are tracked. Default behavior.
+     *
+     * 3. **Partial Opt-In**  
+     *    `userOptOut = true`, `allowSystemEvents = true`  
+     *    → Only system events (e.g., app launch, notification viewed) are tracked. Custom events are ignored.
+     *
+     * ⚠️ The combination `userOptOut = false` and `allowSystemEvents = false` is invalid.  
+     * In such cases, the SDK defaults to **Full Opt-In**.
+     *
+     * To re-enable full tracking after opting out, call with:  
+     * `userOptOut = false`, `allowSystemEvents = true`.
+     *
+     * @param {boolean} userOptOut - Set to `true` to disable custom event tracking.
+     * @param {boolean} allowSystemEvents - Set to `true` to allow system-level event tracking.
+     * @returns {void}
+ */
+    setOptOut: function(userOptOut, allowSystemEvents = false) {
+        CleverTapReact.setOptOut(userOptOut, allowSystemEvents);
+    },
+
+    /**
+    * Sets the CleverTap SDK to offline mode
+    * @param {boolean} value - A boolean for enabling or disabling sending events for current user
+    */
+    setOffline: function (value) {
+        CleverTapReact.setOffline(value);
+    },
+
+    /**
+    * Enables the reporting of device network related information, including IP address. This reporting is disabled by default.
+    * @param {boolean} - A boolean for enabling or disabling device network related information to be sent to CleverTap
+    */
+    enableDeviceNetworkInfoReporting: function (value) {
+        CleverTapReact.enableDeviceNetworkInfoReporting(value);
+    },
+
+    /**
+    * Enables the personalization API.  Call this prior to using the profile/event API getters
+    */
+    enablePersonalization: function () {
+        CleverTapReact.enablePersonalization();
+    },
+
+    /**
+    * Disables the personalization API.
+    */
+    disablePersonalization: function () {
+        CleverTapReact.disablePersonalization();
+    },
+
+    /**
+    * Record a Screen View
+    * @param {string} screenName - the name of the screen
+    */
+    recordScreenView: function (screenName) {
+        CleverTapReact.recordScreenView(screenName);
+    },
+
+    /**
+    * Record an event with optional event properties
+    * @param {string} eventName - the name of the event
+    * @param {object} props - the key-value properties of the event.
+    * keys are strings and values can be string, number or boolean.
+    */
+    recordEvent: function (eventName, props) {
+        convertDateToEpochInProperties(props);
+        CleverTapReact.recordEvent(eventName, props);
+    },
+
+    /**
+    * Record the special Charged event
+    * @param {object} details - the key-value properties for the transaction.
+    * @param {array<object>} items - an array of objects containing the key-value data for the items that make up the transaction.
+    */
+    recordChargedEvent: function (details, items) {
+        convertDateToEpochInProperties(details);
+        if (Array.isArray(items) && items.length) {
+            items.forEach(value => {
+                convertDateToEpochInProperties(value);
+            });
+        }
+        CleverTapReact.recordChargedEvent(details, items);
+    },
+
+    /**
+    * Get the time of the first occurrence of an event
+    * @deprecated - Since version 3.2.0. Use getUserEventLog() instead
+    * @param {string} eventName - the name of the event
+    * @param {function(err, res)} callback that returns a res of epoch seconds or -1
+    */
+    eventGetFirstTime: function (eventName, callback) {
+        callWithCallback('eventGetFirstTime', [eventName], callback);
+    },
+
+    /**
+    * Get the time of the most recent occurrence of an event
+    * @deprecated - Since version 3.2.0. Use getUserEventLog() instead
+    * @param {string} eventName - the name of the event
+    * @param {function(err, res)} callback that returns a res of epoch seconds or -1
+    */
+    eventGetLastTime: function (eventName, callback) {
+        callWithCallback('eventGetLastTime', [eventName], callback);
+    },
+
+    /**
+    * Get the number of occurrences of an event
+    * @deprecated - Since version 3.2.0. Use getUserEventLogCount() instead
+    * @param {string} eventName - the name of the event
+    * @param {function(err, res)} callback that returns a res of int
+    */
+    eventGetOccurrences: function (eventName, callback) {
+        callWithCallback('eventGetOccurrences', [eventName], callback);
+    },
+
+    /**
+    * Get the summary details of an event
+    * @deprecated - Since version 3.2.0. Use getUserEventLog() instead
+    * @param {string} eventName - the name of the event
+    * @param {function(err, res)} callback that returns a res of object {"eventName": <string>, "firstTime":<epoch seconds>, "lastTime": <epoch seconds>, "count": <int>} or empty object
+    */
+    eventGetDetail: function (eventName, callback) {
+        callWithCallback('eventGetDetail', [eventName], callback);
+    },
+
+    /**
+    * Get the user's event history
+    * @deprecated - Since version 3.2.0. Use getUserEventLogHistory() instead
+    * @param {function(err, res)} callback that returns a res of object {"eventName1":<event1 details object>, "eventName2":<event2 details object>}
+    */
+    getEventHistory: function (callback) {
+        callWithCallback('getEventHistory', null, callback);
+    },
+    /**
+    * Get the details of a specific event
+    * @param {string} eventName - the name of the event
+    * @param {function(err, res)} callback that returns a res of object {"eventName": <string>, "firstTime":<epoch seconds>, "lastTime": <epoch seconds>, "count": <int>, "deviceID": <string>, "normalizedEventName": <string>} or empty object
+    */
+    getUserEventLog: function (eventName, callback) {
+        callWithCallback('getUserEventLog', [eventName], callback);
+    },
+    
+    /**
+    * Get the count of times an event occured
+    * @param {string} eventName - the name of the event
+    * @param {function(err, res)} callback that returns a res of int
+    */
+    getUserEventLogCount: function (eventName, callback) {
+        callWithCallback('getUserEventLogCount', [eventName], callback);
+    },
+
+    /**
+    * Get full event hostory for current user
+    * @param {function(err, res)} callback that returns a res of object {"eventName1":<event1 details object>, "eventName2":<event2 details object>}
+    */
+    getUserEventLogHistory: function (callback) {
+        callWithCallback('getUserEventLogHistory', null, callback);
+    },
+
+    /**
+    * Set the user's location as a latitude,longitude coordinate
+    * @param {float} latitude
+    * @param {float} longitude
+    */
+    setLocation: function (latitude, longitude) {
+        CleverTapReact.setLocation(latitude, longitude);
+    },
+
+    /**
+     * @deprecated - Since version 0.6.0. Use getCleverTapID(callback) instead
+    * Get a unique CleverTap identifier suitable for use with install attribution providers
+    * @param {function(err, res)} callback that returns a string res
+    */
+    profileGetCleverTapAttributionIdentifier: function (callback) {
+        callWithCallback('profileGetCleverTapAttributionIdentifier', null, callback);
+    },
+
+    /**
+     * @deprecated - Since version 0.6.0. Use getCleverTapID(callback) instead
+    * Get the user profile's CleverTap identifier value
+    * @param {function(err, res)} callback that returns a string res
+    */
+    profileGetCleverTapID: function (callback) {
+        callWithCallback('profileGetCleverTapID', null, callback);
+    },
+
+    /**
+    * Creates a separate and distinct user profile identified by one or more of Identity, Email, FBID or GPID values, and populated with the key-values included in the profile dictionary.
+    * If your app is used by multiple users, you can use this method to assign them each a unique profile to track them separately.
+    * If instead you wish to assign multiple Identity, Email, FBID and/or GPID values to the same user profile, use profileSet rather than this method.
+    * If none of Identity, Email, FBID or GPID is included in the profile object, all properties values will be associated with the current user profile.
+    * When initially installed on this device, your app is assigned an "anonymous" profile.
+    * The first time you identify a user on this device (whether via onUserLogin or profileSet), the "anonymous" history on the device will be associated with the newly identified user.
+    * Then, use this method to switch between subsequent separate identified users.
+    * Please note that switching from one identified user to another is a costly operation
+    * in that the current session for the previous user is automatically closed
+    * and data relating to the old user removed, and a new session is started
+    * for the new user and data for that user refreshed via a network call to CleverTap.
+    * In addition, any global frequency caps are reset as part of the switch.
+    * @param {object} profile - key-value profile properties.  keys are strings and values can be string, number or boolean.
+    */
+    onUserLogin: function (profile) {
+        convertDateToEpochInProperties(profile);
+        CleverTapReact.onUserLogin(profile);
+    },
+
+    /**
+    * Set key-value properties on a user profile
+    * @param {object} profile - key-value profile properties.  keys are strings and values can be string, number or boolean.
+    */
+    profileSet: function (profile) {
+        convertDateToEpochInProperties(profile);
+        CleverTapReact.profileSet(profile);
+    },
+
+    /**
+    * Get the value of a profile property
+    * @param {string} the property key
+    * @param {function(err, res)} callback that returns a res of the property value or null
+    */
+    profileGetProperty: function (key, callback) {
+        callWithCallback('profileGetProperty', [key], callback);
+    },
+
+    /**
+    * Remove a key-value from the user profile. Alternatively this method can also be used to remove PII data
+    * (for eg. Email,Name,Phone), locally from database and shared prefs
+    * @param {string} the key to remove
+    */
+    profileRemoveValueForKey: function (key) {
+        CleverTapReact.profileRemoveValueForKey(key);
+    },
+
+    /**
+    * Set an array of strings as a multi-value user profile property
+    * @param {array} an array of string values
+    * @param {string} the property key
+    */
+    profileSetMultiValuesForKey: function (values, key) {
+        CleverTapReact.profileSetMultiValues(values, key);
+    },
+
+    /**
+    * Add a string value to a multi-value user profile property
+    * @param {string} value
+    * @param {string} the property key
+    */
+    profileAddMultiValueForKey: function (value, key) {
+        CleverTapReact.profileAddMultiValue(value, key);
+    },
+
+    /**
+    * Add an array of strings to a multi-value user profile property
+    * @param {array} an array of string values
+    * @param {string} the property key
+    */
+    profileAddMultiValuesForKey: function (values, key) {
+        CleverTapReact.profileAddMultiValues(values, key);
+    },
+
+    /**
+    * Remove a string value from a multi-value user profile property
+    * @param {string} value
+    * @param {string} the property key
+    */
+    profileRemoveMultiValueForKey: function (value, key) {
+        CleverTapReact.profileRemoveMultiValue(value, key);
+    },
+
+    /**
+    * Remove an array of strings from a multi-value user profile property
+    * @param {array} an array of string values
+    * @param {string} the property key
+    */
+    profileRemoveMultiValuesForKey: function (values, key) {
+        CleverTapReact.profileRemoveMultiValues(values, key);
+    },
+
+    /**
+    * This method is used to increment the given value
+    *
+    * @param value {Number} can be int,double or float only (NaN,Infinity etc not supported)
+    * @param key   {string} profile property
+    */
+    profileIncrementValueForKey: function (value, key) {
+        CleverTapReact.profileIncrementValueForKey(value, key);
+    },
+
+    /**
+     * This method is used to decrement the given value
+     *
+     * @param value {Number} can be int,double or float only (NaN,Infinity etc not supported)
+     * @param key   {string} profile property
+     */
+    profileDecrementValueForKey: function (value, key) {
+        CleverTapReact.profileDecrementValueForKey(value, key);
+    },
+
+    /**
+    * Manually track the utm app install referrer
+    * @param {string} the utm referrer source
+    * @param {string} the utm referrer medium
+    * @param {string} the utm referrer campaign
+    */
+    pushInstallReferrer: function (source, medium, campaign) {
+        CleverTapReact.pushInstallReferrer(source, medium, campaign);
+    },
+
+    /**
+    * Get the elapsed time of the current user session
+    * @param {function(err, res)} callback that returns a res of int seconds
+    */
+    sessionGetTimeElapsed: function (callback) {
+        callWithCallback('sessionGetTimeElapsed', null, callback);
+    },
+
+    /**
+    * Get the total number of vists by the user
+    * @deprecated - Since version 3.2.0. Use getUserAppLaunchCount() instead
+    * @param {function(err, res)} callback that returns a res of int
+    */
+    sessionGetTotalVisits: function (callback) {
+        callWithCallback('sessionGetTotalVisits', null, callback);
+    },
+
+    /**
+    * Get timestamp of user's last app visit
+    * @param {function(err, res)} callback that returns a res of epoch seconds or -1
+    */
+    getUserLastVisitTs: function (callback) {
+        callWithCallback('getUserLastVisitTs', null, callback);
+    },
+    
+    /**
+    * Get the total number of times user has launched the app
+    * @param {function(err, res)} callback that returns a res of int
+    */
+    getUserAppLaunchCount: function (callback) {
+        callWithCallback('getUserAppLaunchCount', null, callback);
+    },
+
+    /**
+    * Get the number of screens viewed by the user during the session
+    * @param {function(err, res)} callback that returns a res of int
+    */
+    sessionGetScreenCount: function (callback) {
+        callWithCallback('sessionGetScreenCount', null, callback);
+    },
+
+    /**
+    * Get the most recent previous visit time of the user
+    * @deprecated - Since version 3.2.0. Use getUserLastVisits() instead
+    * @param {function(err, res)} callback that returns a res of epoch seconds or -1
+    */
+    sessionGetPreviousVisitTime: function (callback) {
+        callWithCallback('sessionGetPreviousVisitTime', null, callback);
+    },
+
+    /**
+    * Get the utm referrer info for the current session
+    * @param {function(err, res)} callback that returns a res of object {"source": <string>, "medium": <string>, "campaign": <string>} or empty object
+    */
+    sessionGetUTMDetails: function (callback) {
+        callWithCallback('sessionGetUTMDetails', null, callback);
+    },
+
+    /**
+    * Method to initalize the App Inbox
+    */
+    initializeInbox: function () {
+        CleverTapReact.initializeInbox();
+    },
+
+    /**
+    * Method to show the App Inbox
+    * @param {object} styleConfig - key-value profile properties.  keys and values are strings
+    */
+    showInbox: function (styleConfig) {
+        CleverTapReact.showInbox(styleConfig);
+    },
+
+    /**
+     * Method to dismiss the App Inbox
+     */
+    dismissInbox: function () {
+        CleverTapReact.dismissInbox();
+    },
+
+    /**
+     * Get the total number of Inbox Messages
+     * @param {function(err, res)} callback that returns a res of count of inbox messages or -1
+     */
+    getInboxMessageCount: function (callback) {
+        callWithCallback('getInboxMessageCount', null, callback);
+    },
+
+    /**
+     * Get the total number of Unread Inbox Messages
+     * @param {function(err, res)} callback that returns a res of count of unread inbox messages or -1
+     */
+    getInboxMessageUnreadCount: function (callback) {
+        callWithCallback('getInboxMessageUnreadCount', null, callback);
+    },
+
+    /**
+     * Get All inbox messages
+     * @param {function(err, res)} callback that returns a list of json string representation of CTInboxMessage
+     */
+    getAllInboxMessages: function (callback) {
+        callWithCallback('getAllInboxMessages', null, callback);
+    },
+
+    /**
+     * Get All unread inbox messages
+     * @param {function(err, res)} callback that returns a list of json string representation of CTInboxMessage
+     */
+    getUnreadInboxMessages: function (callback) {
+        callWithCallback('getUnreadInboxMessages', null, callback);
+    },
+
+    /**
+     * Get Inbox Message that belongs to the given message id
+     * @param {function(err, res)} callback that returns json string representation of CTInboxMessage
+     */
+    getInboxMessageForId: function (messageId, callback) {
+        callWithCallback('getInboxMessageForId', [messageId], callback);
+    },
+
+    /**
+     * Deletes Inbox Message that belongs to the given message id
+     * @param {string} message id of inbox message of type CTInboxMessage
+     */
+    deleteInboxMessageForId: function (messageId) {
+        CleverTapReact.deleteInboxMessageForId(messageId);
+    },
+
+    /**
+     * Deletes multiple Inbox Messages that belongs to the given message ids
+     * @param {array} messageIds a collection of ids of inbox messages
+     */
+    deleteInboxMessagesForIDs: function (messageIds) {
+        CleverTapReact.deleteInboxMessagesForIDs(messageIds);
+    },
+
+    /**
+     * Marks Inbox Message that belongs to the given message id as read
+     * @param {string} message id of inbox message of type CTInboxMessage
+     */
+    markReadInboxMessageForId: function (messageId) {
+        CleverTapReact.markReadInboxMessageForId(messageId);
+    },
+
+    /**
+     * Marks multiple Inbox Messages that belongs to the given message ids as read
+     * @param {array} messageIds a collection of ids of inbox messages
+     */
+    markReadInboxMessagesForIDs: function (messageIds) {
+        CleverTapReact.markReadInboxMessagesForIDs(messageIds);
+    },
+
+    /**
+     * Pushes the Notification Clicked event for App Inbox to CleverTap.
+     * @param {string} message id of inbox message of type CTInboxMessage
+     */
+    pushInboxNotificationClickedEventForId: function (messageId) {
+        CleverTapReact.pushInboxNotificationClickedEventForId(messageId);
+    },
+
+    /**
+     * Pushes the Notification Viewed event for App Inbox to CleverTap.
+     * @param {string} message id of inbox message of type CTInboxMessage
+     */
+    pushInboxNotificationViewedEventForId: function (messageId) {
+        CleverTapReact.pushInboxNotificationViewedEventForId(messageId);
+    },
+
+    /**
+     * Get all display units
+     * @param {function(err, res)} callback that returns a list of json string representation of CleverTapDisplayUnit
+     */
+    getAllDisplayUnits: function (callback) {
+        callWithCallback('getAllDisplayUnits', null, callback);
+    },
+
+    /**
+     * Get display unit for given unitID.
+     * @param {string} unit id of display unit of type CleverTapDisplayUnit
+     * @param {function(err, res)} callback that returns a json string representation of CleverTapDisplayUnit
+     */
+    getDisplayUnitForId: function (unitID, callback) {
+        callWithCallback('getDisplayUnitForId', [unitID], callback);
+    },
+
+    /**
+     * Raises the Display Unit Viewed event
+     * @param {string} unit id of display unit of type CleverTapDisplayUnit
+     */
+    pushDisplayUnitViewedEventForID: function (unitID) {
+        CleverTapReact.pushDisplayUnitViewedEventForID(unitID);
+    },
+
+    /**
+     * Raises the Display Unit Clicked event
+     * @param {string} unit id of display unit of type CleverTapDisplayUnit
+     */
+    pushDisplayUnitClickedEventForID: function (unitID) {
+        CleverTapReact.pushDisplayUnitClickedEventForID(unitID);
+    },
+
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Sets default product config params using the given object.
+     * @param {object} productConfigMap - key-value product config properties.  keys are strings and values can be string, double, integer, boolean or json in string format.
+     */
+    setDefaultsMap: function (productConfigMap) {
+        CleverTapReact.setDefaultsMap(productConfigMap);
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Starts fetching product configs, adhering to the default minimum fetch interval.
+     */
+    fetch: function () {
+        CleverTapReact.fetch();
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Starts fetching product configs, adhering to the specified minimum fetch interval in seconds.
+     * @param {int} intervalInSecs - minimum fetch interval in seconds.
+     */
+    fetchWithMinimumIntervalInSeconds: function (intervalInSecs) {
+        CleverTapReact.fetchWithMinimumFetchIntervalInSeconds(intervalInSecs);
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Activates the most recently fetched product configs, so that the fetched key value pairs take effect.
+     */
+    activate: function () {
+        CleverTapReact.activate();
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Asynchronously fetches and then activates the fetched product configs.
+     */
+    fetchAndActivate: function () {
+        CleverTapReact.fetchAndActivate();
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Sets the minimum interval in seconds between successive fetch calls.
+     * @param {int} intervalInSecs - interval in seconds between successive fetch calls.
+     */
+    setMinimumFetchIntervalInSeconds: function (intervalInSecs) {
+        CleverTapReact.setMinimumFetchIntervalInSeconds(intervalInSecs);
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Deletes all activated, fetched and defaults configs as well as all Product Config settings.
+     */
+    resetProductConfig: function () {
+        CleverTapReact.reset();
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     *
+     * Returns the product config parameter value for the given key as a String.
+     * @param {string} the property key
+     * @param {function(err, res)} callback that returns a value of type string if present else blank
+     */
+    getProductConfigString: function (key, callback) {
+        callWithCallback('getString', [key], callback);
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Returns the product config parameter value for the given key as a boolean.
+     * @param {string} the property key
+     * @param {function(err, res)} callback that returns a value of type boolean if present else false
+     */
+    getProductConfigBoolean: function (key, callback) {
+        callWithCallback('getBoolean', [key], callback);
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Returns the product config parameter value for the given key as a number.
+     * @param {string} the property key
+     * @param {function(err, res)} callback that returns a value of type number if present else 0
+     */
+    getNumber: function (key, callback) {
+        callWithCallback('getDouble', [key], callback);
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Returns the last fetched timestamp in millis.
+     * @param {function(err, res)} callback that returns value of timestamp in millis as a string.
+     */
+    getLastFetchTimeStampInMillis: function (callback) {
+        callWithCallback('getLastFetchTimeStampInMillis', null, callback);
+    },
+
+    /**
+     * @deprecated - Since version 1.1.0 and will be removed in the future versions of this SDK.
+     * 
+     * Getter to return the feature flag configured at the dashboard
+     * @param {string} key of the feature flag
+     * @param {string} default value of the key, in case we don't find any feature flag with the key.
+     * @param {function(err, res)} callback that returns a feature flag value of type boolean if present else provided default value
+     */
+    getFeatureFlag: function (name, defaultValue, callback) {
+        callWithCallback('getFeatureFlag', [name, defaultValue], callback);
+    },
+
+    /**
+     * Returns a unique identifier through callback by which CleverTap identifies this user
+     *
+     * @param {function(err, res)} non-null callback to retrieve identifier
+     */
+    getCleverTapID: function (callback) {
+        callWithCallback('getCleverTapID', null, callback);
+    },
+
+    /**
+     * Suspends display of InApp Notifications.
+     * The InApp Notifications are queued once this method is called
+     * and will be displayed once resumeInAppNotifications() is called.
+     */
+    suspendInAppNotifications: function () {
+        CleverTapReact.suspendInAppNotifications();
+    },
+
+    /**
+     * Suspends the display of InApp Notifications and discards any new InApp Notifications to be shown
+     * after this method is called.
+     * The InApp Notifications will be displayed only once resumeInAppNotifications() is called.
+     * @param {boolean} dismissInAppIfVisible - Optional. If true, dismisses the currently visible InApp notification.
+     */
+    discardInAppNotifications: function (dismissInAppIfVisible = false) {
+        CleverTapReact.discardInAppNotifications(dismissInAppIfVisible);
+    },
+
+    /**
+     * Resumes display of InApp Notifications.
+     *
+     * If suspendInAppNotifications() was called previously, calling this method will instantly show
+     * all queued InApp Notifications and also resume InApp Notifications on events raised after this
+     * method is called.
+     *
+     * If discardInAppNotifications() was called previously, calling this method will only resume
+     * InApp Notifications on events raised after this method is called.
+     */
+    resumeInAppNotifications: function () {
+        CleverTapReact.resumeInAppNotifications();
+    },
+
+    /**
+    * Set the SDK debug level
+    * @param {int} 0 = off, 1 = on
+    */
+    setDebugLevel: function (level) {
+        CleverTapReact.setDebugLevel(level);
+    },
+
+    /**
+     * Change the native instance of CleverTapAPI by using the instance for
+     * specific account. Used by Leanplum RN SDK.
+     *
+     * @param accountId The ID of the account to use when switching instance.
+     */
+    setInstanceWithAccountId: function (accountId) {
+        CleverTapReact.setInstanceWithAccountId(accountId);
+    },
+
+    /**
+    * Uploads variables to the server. Requires Development/Debug build/configuration.
+    */
+    syncVariables: function () {
+        CleverTapReact.syncVariables();
+    },
+
+    /**
+    * Uploads variables to the server.
+    *
+    * @param {boolean} isProduction Provide `true` if variables must be sync in Productuon build/configuration.
+    */
+    syncVariablesinProd: function (isProduction) {
+        CleverTapReact.syncVariablesinProd(isProduction)
+    },
+
+    /**
+    * Forces variables to update from the server.
+    *
+    */
+    fetchVariables: function (callback) {
+        callWithCallback('fetchVariables', null, callback);
+    },
+
+    /**
+     * Create variables. 
+     * 
+     * @param {object} variables The JSON Object specifying the varibles to be created.
+     */
+    defineVariables: function (variables) {
+        CleverTapReact.defineVariables(variables);
+    },
+
+    /**
+    * Create File Variable
+    * @param {string} fileVariable - the file variable string
+    */
+    defineFileVariable: function (fileVariable) {
+        CleverTapReact.defineFileVariable(fileVariable)
+    },
+    
+    /**
+     * Get a variable or a group for the specified name.
+     * 
+     * @param {string} name - name.
+     */
+    getVariable: function (name, callback) {
+        callWithCallback('getVariable', [name], callback);
+    },
+
+    /**
+     * Get all variables via a JSON object.
+     * 
+     */
+    getVariables: function (callback) {
+        callWithCallback('getVariables', null, callback);
+    },
+
+    /**
+     *  Adds a callback to be invoked when variables are initialised with server values. Will be called each time new values are fetched.
+     * 
+     * @param {function} handler The callback to add
+     */
+    onVariablesChanged: function (handler) {
+        CleverTapReact.onVariablesChanged();
+        this.addListener(CleverTapReact.getConstants().CleverTapOnVariablesChanged, handler);
+    },
+
+    /**
+     *  Adds a callback to be invoked only once on app start, or when added if server values are already received
+     *
+     * @param {function} handler The callback to add
+     */
+    onOneTimeVariablesChanged: function (handler) {
+        this.addOneTimeListener(CleverTapReact.getConstants().CleverTapOnOneTimeVariablesChanged, handler);
+        CleverTapReact.onOneTimeVariablesChanged();
+    },
+
+    /**
+     * Called when the value of the variable changes.
+     * 
+     * @param {name} string the name of the variable
+     * @param {function} handler The callback to add
+     */
+    onValueChanged: function (name, handler) {
+        CleverTapReact.onValueChanged(name);
+        this.addListener(CleverTapReact.getConstants().CleverTapOnValueChanged, handler);
+    },
+
+    /**
+     *  Adds a callback to be invoked when variables are initialised with server values. Will be called each time new values are fetched.
+     * 
+     * @param {function} handler The callback to add
+     */
+    onVariablesChangedAndNoDownloadsPending: function (handler) {
+        this.addListener(CleverTapReact.getConstants().CleverTapOnVariablesChangedAndNoDownloadsPending, handler);
+        CleverTapReact.onVariablesChangedAndNoDownloadsPending();
+    },
+
+    /**
+     *  Adds a callback to be invoked only once for when new values are fetched and downloaded
+     *
+     * @param {function} handler The callback to add
+     */
+    onceVariablesChangedAndNoDownloadsPending: function (handler) {
+        this.addOneTimeListener(CleverTapReact.getConstants().CleverTapOnceVariablesChangedAndNoDownloadsPending, handler);
+        CleverTapReact.onceVariablesChangedAndNoDownloadsPending();
+    },
+
+    /**
+     * Called when the value of the file variable is downloaded and ready.
+     * 
+     * @param {name} string the name of the file variable
+     * @param {function} handler The callback to add
+     */
+    onFileValueChanged: function (name, handler) {
+        this.addListener(CleverTapReact.getConstants().CleverTapOnFileValueChanged, handler);
+        CleverTapReact.onFileValueChanged(name);
+    },
+
+    /**
+     * Fetches In Apps from server.
+     *
+     * @param callback {function(err, res)} a callback with a boolean flag whether the update was successful
+     */
+    fetchInApps: function (callback) {
+        callWithCallback('fetchInApps', null, callback);
+    },
+
+    /**
+     * Deletes all images and gifs which are preloaded for inapps in cs mode
+     *
+     * @param {boolean} expiredOnly to clear only assets which will not be needed further for inapps
+     */
+    clearInAppResources: function (expiredOnly) {
+        CleverTapReact.clearInAppResources(expiredOnly);
+    },
+
+    /**
+     * Uploads Custom in-app templates and app functions to the server.
+     * Requires Development/Debug build/configuration.
+     */
+    syncCustomTemplates: function () {
+        CleverTapReact.syncCustomTemplates();
+    },
+
+    /**
+     * Uploads Custom in-app templates and app functions to the server.
+     *
+     * @param {boolean} isProduction Provide `true` if templates must be sync in Productuon build/configuration.
+     */
+    syncCustomTemplatesInProd: function (isProduction) {
+        CleverTapReact.syncCustomTemplatesInProd(isProduction)
+    },
+
+    /**
+     * Returns information about the active variants for the current user. Each variant will contain
+     * an "id" key mapping to the numeric ID of the variant.
+     * 
+     * @param {function(err, res)} callback that returns a list of variant objects
+     */
+    variants: function (callback) {
+        callWithCallback('variants', null, callback);
+    },
+
+    /**
+     * Notify the SDK that an active custom template is dismissed. The active custom template is considered to be
+     * visible to the user until this method is called. Since the SDK can show only one InApp message at a time, all
+     * other messages will be queued until the current one is dismissed.
+     * 
+     * @param {string} templateName The name of the active template
+     */
+    customTemplateSetDismissed: function (templateName) {
+        return CleverTapReact.customTemplateSetDismissed(templateName);
+    },
+
+    /**
+     * Notify the SDK that an active custom template is presented to the user
+     * 
+     * @param {string} templateName The name of the active template
+     */
+    customTemplateSetPresented: function (templateName) {
+        return CleverTapReact.customTemplateSetPresented(templateName);
+    },
+
+    /**
+     * Trigger a custom template action argument by name.
+     * 
+     * @param {string} templateName The name of an active template for which the action is defined
+     * @param {string} argName The action argument name
+     */
+    customTemplateRunAction: function (templateName, argName) {
+        return CleverTapReact.customTemplateRunAction(templateName, argName);
+    },
+
+    /**
+     * Retrieve a string argument by name.
+     *
+     * @param {string} templateName The name of an active template for which the argument is defined
+     * @param {string} argName The action argument name
+     * 
+     * @returns {string} The argument value or null if no such argument is defined for the template.
+     */
+    customTemplateGetStringArg: function (templateName, argName) {
+       return CleverTapReact.customTemplateGetStringArg(templateName, argName);
+    },
+
+    /**
+     * Retrieve a number argument by name.
+     *
+     * @param {string} templateName The name of an active template for which the argument is defined
+     * @param {string} argName The action argument name
+     * 
+     * @returns {number} The argument value or null if no such argument is defined for the template.
+     */
+    customTemplateGetNumberArg: function (templateName, argName) {
+        return CleverTapReact.customTemplateGetNumberArg(templateName, argName);
+    },
+
+    /**
+     * Retrieve a boolean argument by name.
+     *
+     * @param {string} templateName The name of an active template for which the argument is defined
+     * @param {stirng} argName The action argument name
+     * 
+     * @returns {boolean} The argument value or null if no such argument is defined for the template.
+     */
+    customTemplateGetBooleanArg: function (templateName, argName) {
+        return CleverTapReact.customTemplateGetBooleanArg(templateName, argName);
+    },
+
+    /**
+     * Retrieve a file argument by name.
+     *
+     * @param {string} templateName The name of an active template for which the argument is defined
+     * @param {string} argName The action argument name
+     * 
+     * @returns {string} The file path to the file or null if no such argument is defined for the template.
+     */
+    customTemplateGetFileArg: function (templateName, argName) {
+        return CleverTapReact.customTemplateGetFileArg(templateName, argName);
+    },
+
+    /**
+     * Retrieve an object argument by name.
+     *
+     * @param {string} templateName The name of an active template for which the argument is defined
+     * @param {string} argName The action argument name
+     * 
+     * @returns {any} The argument value or null if no such argument is defined for the template.
+     */
+    customTemplateGetObjectArg: function (templateName, argName) {
+        return CleverTapReact.customTemplateGetObjectArg(templateName, argName);
+    },
+
+    /**
+     * Get a string representation of an active's template context with information about all arguments. 
+     * 
+     * @param {string} templateName The name of an active template
+     * @returns {string}
+     */
+    customTemplateContextToString: function (templateName) {
+        return CleverTapReact.customTemplateContextToString(templateName);
+    }
+};
+
+function convertDateToEpochInProperties(map) {
+    /**
+     * Conversion of date object in suitable CleverTap format(Epoch)
+     * Recursively handles nested objects and arrays
+     */
+    if (map) {
+        for (let [key, value] of Object.entries(map)) {
+            if (Object.prototype.toString.call(value) === '[object Date]') {
+                map[key] = "$D_" + Math.floor(value.getTime() / 1000);
+            } else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                // Recursively convert dates in nested objects
+                convertDateToEpochInProperties(value);
+            } else if (Array.isArray(value)) {
+                  value.forEach((item, index) => {
+                      if (Object.prototype.toString.call(item) === '[object Date]') {
+                          value[index] = "$D_" + Math.floor(item.getTime() / 1000);
+                      } else if (item !== null && typeof item === 'object') {
+                          convertDateToEpochInProperties(item);
+                      }
+                  });
+              }
+        }
+    }
+
+};
+
+module.exports = CleverTap;