@kameleoon/javascript-sdk-core 1.1.1 → 2.1.0

package/dist/index.js

@@ -1,30 +1,311 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PageView = exports.BrowserType = exports.DeviceType = exports.Browser = exports.Device = exports.Conversion = exports.CustomData = exports.VariableType = exports.Environment = exports.Err = exports.Ok = exports.VISITOR_CODE_LENGTH = exports.Cookie = exports.KameleoonStorageKey = exports.KameleoonError = exports.KameleoonException = exports.KameleoonCoreUtils = exports.KameleoonCore = void 0;
-var kameleoonClient_1 = require("./kameleoonClient");
-Object.defineProperty(exports, "KameleoonCore", { enumerable: true, get: function () { return kameleoonClient_1.KameleoonClient; } });
-var kameleoonUtils_1 = require("./kameleoonUtils");
-Object.defineProperty(exports, "KameleoonCoreUtils", { enumerable: true, get: function () { return kameleoonUtils_1.KameleoonUtils; } });
-var kameleoonError_1 = require("./kameleoonError");
-Object.defineProperty(exports, "KameleoonException", { enumerable: true, get: function () { return kameleoonError_1.KameleoonException; } });
-Object.defineProperty(exports, "KameleoonError", { enumerable: true, get: function () { return kameleoonError_1.KameleoonError; } });
-var storage_1 = require("./storage");
-Object.defineProperty(exports, "KameleoonStorageKey", { enumerable: true, get: function () { return storage_1.KameleoonStorageKey; } });
-var constants_1 = require("./constants");
-Object.defineProperty(exports, "Cookie", { enumerable: true, get: function () { return constants_1.Cookie; } });
-Object.defineProperty(exports, "VISITOR_CODE_LENGTH", { enumerable: true, get: function () { return constants_1.VISITOR_CODE_LENGTH; } });
-var ts_res_1 = require("ts-res");
-Object.defineProperty(exports, "Ok", { enumerable: true, get: function () { return ts_res_1.Ok; } });
-Object.defineProperty(exports, "Err", { enumerable: true, get: function () { return ts_res_1.Err; } });
-var types_1 = require("./types");
-Object.defineProperty(exports, "Environment", { enumerable: true, get: function () { return types_1.Environment; } });
-Object.defineProperty(exports, "VariableType", { enumerable: true, get: function () { return types_1.VariableType; } });
-var kameleoonData_1 = require("./kameleoonData");
-Object.defineProperty(exports, "CustomData", { enumerable: true, get: function () { return kameleoonData_1.CustomData; } });
-Object.defineProperty(exports, "Conversion", { enumerable: true, get: function () { return kameleoonData_1.Conversion; } });
-Object.defineProperty(exports, "Device", { enumerable: true, get: function () { return kameleoonData_1.Device; } });
-Object.defineProperty(exports, "Browser", { enumerable: true, get: function () { return kameleoonData_1.Browser; } });
-Object.defineProperty(exports, "DeviceType", { enumerable: true, get: function () { return kameleoonData_1.DeviceType; } });
-Object.defineProperty(exports, "BrowserType", { enumerable: true, get: function () { return kameleoonData_1.BrowserType; } });
-Object.defineProperty(exports, "PageView", { enumerable: true, get: function () { return kameleoonData_1.PageView; } });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Browser", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.Browser;
+  }
+});
+Object.defineProperty(exports, "BrowserType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.BrowserType;
+  }
+});
+Object.defineProperty(exports, "CLEANUP_TARGETING_DATA_INTERVAL", {
+  enumerable: true,
+  get: function () {
+    return _campaignConfiguration.CLEANUP_TARGETING_DATA_INTERVAL;
+  }
+});
+Object.defineProperty(exports, "ClientGetVisitorCodeParametersType", {
+  enumerable: true,
+  get: function () {
+    return _types.ClientGetVisitorCodeParametersType;
+  }
+});
+Object.defineProperty(exports, "Conversion", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.Conversion;
+  }
+});
+Object.defineProperty(exports, "ConversionParametersType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.ConversionParametersType;
+  }
+});
+Object.defineProperty(exports, "Cookie", {
+  enumerable: true,
+  get: function () {
+    return _constants.Cookie;
+  }
+});
+Object.defineProperty(exports, "CustomData", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.CustomData;
+  }
+});
+Object.defineProperty(exports, "Device", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.Device;
+  }
+});
+Object.defineProperty(exports, "DeviceType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.DeviceType;
+  }
+});
+Object.defineProperty(exports, "Environment", {
+  enumerable: true,
+  get: function () {
+    return _types.Environment;
+  }
+});
+Object.defineProperty(exports, "Err", {
+  enumerable: true,
+  get: function () {
+    return _tsRes.Err;
+  }
+});
+Object.defineProperty(exports, "EventSourceOpenParametersType", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.EventSourceOpenParametersType;
+  }
+});
+Object.defineProperty(exports, "ExperimentType", {
+  enumerable: true,
+  get: function () {
+    return _types.ExperimentType;
+  }
+});
+Object.defineProperty(exports, "ExternalPackageInfoType", {
+  enumerable: true,
+  get: function () {
+    return _types.ExternalPackageInfoType;
+  }
+});
+Object.defineProperty(exports, "FeatureFlagType", {
+  enumerable: true,
+  get: function () {
+    return _types.FeatureFlagType;
+  }
+});
+Object.defineProperty(exports, "FeatureVariableResultType", {
+  enumerable: true,
+  get: function () {
+    return _types.FeatureVariableResultType;
+  }
+});
+Object.defineProperty(exports, "GetClientConfigurationResultType", {
+  enumerable: true,
+  get: function () {
+    return _requester.GetClientConfigurationResultType;
+  }
+});
+Object.defineProperty(exports, "GetFeatureFlagVariableParamsType", {
+  enumerable: true,
+  get: function () {
+    return _types.GetFeatureFlagVariableParamsType;
+  }
+});
+Object.defineProperty(exports, "Header", {
+  enumerable: true,
+  get: function () {
+    return _requester.Header;
+  }
+});
+Object.defineProperty(exports, "HttpMethod", {
+  enumerable: true,
+  get: function () {
+    return _requester.HttpMethod;
+  }
+});
+Object.defineProperty(exports, "IExternalEventSource", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.IExternalEventSource;
+  }
+});
+Object.defineProperty(exports, "IExternalEventSourceConstructor", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.IExternalEventSourceConstructor;
+  }
+});
+Object.defineProperty(exports, "IExternalRequestDispatcher", {
+  enumerable: true,
+  get: function () {
+    return _requester.IExternalRequestDispatcher;
+  }
+});
+Object.defineProperty(exports, "IExternalStorage", {
+  enumerable: true,
+  get: function () {
+    return _storage.IExternalStorage;
+  }
+});
+Object.defineProperty(exports, "IExternalStorageConstructor", {
+  enumerable: true,
+  get: function () {
+    return _storage.IExternalStorageConstructor;
+  }
+});
+Object.defineProperty(exports, "IKameleoonCore", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonClient.IKameleoonClient;
+  }
+});
+Object.defineProperty(exports, "InternalSDKConfigurationType", {
+  enumerable: true,
+  get: function () {
+    return _types.InternalSDKConfigurationType;
+  }
+});
+Object.defineProperty(exports, "JSONType", {
+  enumerable: true,
+  get: function () {
+    return _campaignConfiguration.JSONType;
+  }
+});
+Object.defineProperty(exports, "KameleoonCore", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonClient.KameleoonClient;
+  }
+});
+Object.defineProperty(exports, "KameleoonCoreUtils", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonUtils.KameleoonUtils;
+  }
+});
+Object.defineProperty(exports, "KameleoonDataType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.KameleoonDataType;
+  }
+});
+Object.defineProperty(exports, "KameleoonError", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonError.KameleoonError;
+  }
+});
+Object.defineProperty(exports, "KameleoonException", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonError.KameleoonException;
+  }
+});
+Object.defineProperty(exports, "KameleoonStorageKey", {
+  enumerable: true,
+  get: function () {
+    return _storage.KameleoonStorageKey;
+  }
+});
+Object.defineProperty(exports, "MobileGetVisitorCodeParametersType", {
+  enumerable: true,
+  get: function () {
+    return _types.MobileGetVisitorCodeParametersType;
+  }
+});
+Object.defineProperty(exports, "Ok", {
+  enumerable: true,
+  get: function () {
+    return _tsRes.Ok;
+  }
+});
+Object.defineProperty(exports, "PageView", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.PageView;
+  }
+});
+Object.defineProperty(exports, "PageViewParametersType", {
+  enumerable: true,
+  get: function () {
+    return _kameleoonData.PageViewParametersType;
+  }
+});
+Object.defineProperty(exports, "RealTimeEventType", {
+  enumerable: true,
+  get: function () {
+    return _eventSource.RealTimeEventType;
+  }
+});
+Object.defineProperty(exports, "Result", {
+  enumerable: true,
+  get: function () {
+    return _tsRes.Result;
+  }
+});
+Object.defineProperty(exports, "SDKConfigurationType", {
+  enumerable: true,
+  get: function () {
+    return _types.SDKConfigurationType;
+  }
+});
+Object.defineProperty(exports, "SDKCoreParameters", {
+  enumerable: true,
+  get: function () {
+    return _types.SDKCoreParameters;
+  }
+});
+Object.defineProperty(exports, "SDKType", {
+  enumerable: true,
+  get: function () {
+    return _constants.SDKType;
+  }
+});
+Object.defineProperty(exports, "ServerGetVisitorCodeParametersType", {
+  enumerable: true,
+  get: function () {
+    return _types.ServerGetVisitorCodeParametersType;
+  }
+});
+Object.defineProperty(exports, "TrackConversionParamsType", {
+  enumerable: true,
+  get: function () {
+    return _types.TrackConversionParamsType;
+  }
+});
+Object.defineProperty(exports, "TrackParametersType", {
+  enumerable: true,
+  get: function () {
+    return _requester.TrackParametersType;
+  }
+});
+Object.defineProperty(exports, "VISITOR_CODE_LENGTH", {
+  enumerable: true,
+  get: function () {
+    return _constants.VISITOR_CODE_LENGTH;
+  }
+});
+Object.defineProperty(exports, "VariableType", {
+  enumerable: true,
+  get: function () {
+    return _types.VariableType;
+  }
+});
+var _kameleoonClient = require("./kameleoonClient");
+var _kameleoonUtils = require("./kameleoonUtils");
+var _kameleoonError = require("./kameleoonError");
+var _storage = require("./storage");
+var _constants = require("./constants");
+var _campaignConfiguration = require("./campaignConfiguration");
+var _tsRes = require("ts-res");
+var _types = require("./types");
+var _kameleoonData = require("./kameleoonData");
+var _eventSource = require("./eventSource");
+var _requester = require("./requester");
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,qDAG2B;AAFzB,gHAAA,eAAe,OAAiB;AAGlC,mDAAwE;AAA/D,oHAAA,cAAc,OAAsB;AAC7C,mDAAsE;AAA7D,oHAAA,kBAAkB,OAAA;AAAE,gHAAA,cAAc,OAAA;AAC3C,qCAImB;AAHjB,8GAAA,mBAAmB,OAAA;AAIrB,yCAA0D;AAAjD,mGAAA,MAAM,OAAA;AAAE,gHAAA,mBAAmB,OAAA;AAEpC,iCAAyC;AAAhC,4FAAA,EAAE,OAAA;AAAU,6FAAA,GAAG,OAAA;AACxB,iCAciB;AAbf,oGAAA,WAAW,OAAA;AACX,qGAAA,YAAY,OAAA;AAad,iDAWyB;AAVvB,2GAAA,UAAU,OAAA;AACV,2GAAA,UAAU,OAAA;AACV,uGAAA,MAAM,OAAA;AACN,wGAAA,OAAO,OAAA;AACP,2GAAA,UAAU,OAAA;AACV,4GAAA,WAAW,OAAA;AACX,yGAAA,QAAQ,OAAA"}
+{"version":3,"file":"index.js","names":["_kameleoonClient","require","_kameleoonUtils","_kameleoonError","_storage","_constants","_campaignConfiguration","_tsRes","_types","_kameleoonData","_eventSource","_requester"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  KameleoonClient as KameleoonCore,\n  IKameleoonClient as IKameleoonCore,\n} from './kameleoonClient';\nexport { KameleoonUtils as KameleoonCoreUtils } from './kameleoonUtils';\nexport { KameleoonException, KameleoonError } from './kameleoonError';\nexport {\n  KameleoonStorageKey,\n  IExternalStorage,\n  IExternalStorageConstructor,\n} from './storage';\nexport { Cookie, VISITOR_CODE_LENGTH, SDKType } from './constants';\nexport { CLEANUP_TARGETING_DATA_INTERVAL } from './campaignConfiguration';\nexport { JSONType } from './campaignConfiguration';\nexport { Ok, Result, Err } from 'ts-res';\nexport {\n  Environment,\n  VariableType,\n  ExperimentType,\n  FeatureFlagType,\n  SDKCoreParameters,\n  SDKConfigurationType,\n  ExternalPackageInfoType,\n  TrackConversionParamsType,\n  FeatureVariableResultType,\n  InternalSDKConfigurationType,\n  GetFeatureFlagVariableParamsType,\n  ServerGetVisitorCodeParametersType,\n  ClientGetVisitorCodeParametersType,\n  MobileGetVisitorCodeParametersType,\n} from './types';\nexport {\n  CustomData,\n  Conversion,\n  Device,\n  Browser,\n  DeviceType,\n  BrowserType,\n  PageView,\n  KameleoonDataType,\n  PageViewParametersType,\n  ConversionParametersType,\n} from './kameleoonData';\nexport {\n  RealTimeEventType,\n  IExternalEventSource,\n  EventSourceOpenParametersType,\n  IExternalEventSourceConstructor,\n} from './eventSource';\nexport {\n  Header,\n  HttpMethod,\n  TrackParametersType,\n  IExternalRequestDispatcher,\n  GetClientConfigurationResultType,\n} from './requester';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA;AAIA,IAAAC,eAAA,GAAAD,OAAA;AACA,IAAAE,eAAA,GAAAF,OAAA;AACA,IAAAG,QAAA,GAAAH,OAAA;AAKA,IAAAI,UAAA,GAAAJ,OAAA;AACA,IAAAK,sBAAA,GAAAL,OAAA;AAEA,IAAAM,MAAA,GAAAN,OAAA;AACA,IAAAO,MAAA,GAAAP,OAAA;AAgBA,IAAAQ,cAAA,GAAAR,OAAA;AAYA,IAAAS,YAAA,GAAAT,OAAA;AAMA,IAAAU,UAAA,GAAAV,OAAA"}

package/dist/kameleoonClient.d.ts

@@ -3,7 +3,7 @@ import { KameleoonDataType } from './kameleoonData';
 import { TrackConversionParamsType, ExperimentType, FeatureFlagType, GetFeatureFlagVariableParamsType, FeatureVariableResultType, SDKCoreParameters } from './types';
 /**
  * @interface an interface of KameleoonClient instance
- * */
+ */
 export interface IKameleoonClient {
     /**
      * @method initialize - an asynchronous method for KameleoonClient initialization by fetching Kameleoon SDK related data from server or by retrieving data from local source if data is up-to-date or update interval has not been reached
@@ -12,7 +12,7 @@ export interface IKameleoonClient {
      *
      * - `KameleoonException.StorageWrite` Couldn't update storage data
      * - `KameleoonException.ClientConfiguration` Couldn't retrieve client configuration from Kameleoon Api
-     * */
+     */
     initialize: () => Promise<boolean>;
     /**
      * @method addData - method for adding targeting data to the storage so that other methods could decide whether the current visitor is targeted or not. Note: userAgent data will not be stored in storage like other data, and it will be sent with every tracking request for bot filtration.
@@ -24,7 +24,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded
      * - `KameleoonException.StorageWrite` Couldn't update storage data
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     addData: (visitorCode: string, ...data: KameleoonDataType[]) => void;
     /**
      * @method triggerExperiment - triggers experiment by assigning the variation to the user with `visitorCode`, if the variation is already assigned just returns it's id. Note: returned id `0` indicates default variation.  At the same time executes `flushData` without sending extra request.
@@ -38,7 +38,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.StorageRead` Couldn't find associated experiment by provided `experimentId` and `visitorCode` inside the storage
      * - `KameleoonException.NotTargeted` Current visitor is not targeted
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     triggerExperiment: (visitorCode: string, experimentId: number) => number;
     /**
      * @method trackConversion - creates and adds `Conversion` data to the visitor with specified parameters and executes `flushData`. Note: it's a helper method for the quick and convenient conversion tracking, however creating and adding `Conversion` manually allows more flexible `Conversion` with `negative` parameter
@@ -48,7 +48,7 @@ export interface IKameleoonClient {
      *
      * - `KameleoonException.VisitorCodeMaxLength` The visitor code length was exceeded
      * - `KameleoonException.StorageWrite` Couldn't update storage data
-     * */
+     */
     trackConversion: ({ visitorCode, goalId, revenue, }: TrackConversionParamsType) => void;
     /**
      * @method flushData - takes visitor associated kameleoon data and sends the data tracking request with collected data
@@ -58,7 +58,7 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     flushData: (visitorCode: string) => void;
     /**
      * @method getExperiments - returns a list of experiments stored in the client configuration
@@ -66,7 +66,7 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     getExperiments: () => ExperimentType[];
     /**
      * @method getVisitorExperiments - returns a list of experiments that the visitor with `visitorCode` is targeted by and that are *active* for the visitor (visitor will have one of the variations allocated if the experiment will be triggered).
@@ -77,15 +77,25 @@ export interface IKameleoonClient {
      *
      * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     getVisitorExperiments: (visitorCode: string, isAllocated?: boolean) => ExperimentType[];
+    /**
+     * @method getExperimentVariationData - returns variation data in JSON format for the variation with `variationId`
+     * @param {number} variationId - id of variation
+     * @returns {JSONType} variation data in JSON format
+     * @throws `KameleoonError` with one of the following `type` s:
+     * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
+     * - `KameleoonException.JSONParse` - Couldn't pass JSON value
+     * - `KameleoonException.VariationNotFound` - No variation found for provided `variationId`
+     */
+    getExperimentVariationData: (variationId: number) => JSONType | null;
     /**
      * @method getFeatureFlags - returns a list of feature flags stored in the client configuration
      * @returns {FeatureFlagType[]} a list of all feature flags items with `id` and `key` fields
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     getFeatureFlags: () => FeatureFlagType[];
     /**
      * @method getVisitorFeatureFlags - returns a list of feature flags that the visitor with `visitorCode` that is targeted by and that are *active* for the visitor (visitor will have one of the variations allocated).
@@ -96,10 +106,10 @@ export interface IKameleoonClient {
      * - `KameleoonException.VisitorCodeMaxLength` - The visitor code length was exceeded
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
-     * */
+     */
     getVisitorFeatureFlags: (visitorCode: string) => FeatureFlagType[];
     /**
-     * @method isFeatureFlagActive - returns a boolean indicating whether the visitor with `visitorCode` has `featureKey` active for him, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`
+     * @method isFeatureFlagActive - returns a boolean indicating whether the visitor with `visitorCode` has `featureKey` active for him, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request
      * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length
      * @param {string} featureKey - a unique key for feature flag
      * @returns {boolean} a boolean indicator of whether the feature flag with `featureKey` is active for visitor with `visitorCode`
@@ -110,10 +120,10 @@ export interface IKameleoonClient {
      * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`
      * - `KameleoonException.DataInconsistency` - Allocated variation was found but there is no feature flag with according `featureKey`.
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
-     * */
+     */
     isFeatureFlagActive: (visitorCode: string, featureKey: string) => boolean;
     /**
-     * @method getFeatureFlagVariationKey - returns variation key for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`
+     * @method getFeatureFlagVariationKey - returns variation key for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request
      * @param {string} visitorCode - unique visitor identification string, can't exceed 255 characters length
      * @param {string} featureKey - a unique key for feature flag
      * @returns {string} a string containing variable key for the allocated feature flag variation for the provided visitor
@@ -123,10 +133,10 @@ export interface IKameleoonClient {
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
      * - `KameleoonException.FeatureFlagConfigurationNotFound` - No feature flag was found for provided `visitorCode` and `featureKey`
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
-     * */
+     */
     getFeatureFlagVariationKey: (visitorCode: string, featureKey: string) => string;
     /**
-     * @method getFeatureFlagVariable - returns a variable for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request if the feature rollout rule was of type of `Experimentation`
+     * @method getFeatureFlagVariable - returns a variable for the visitor under `visitorCode` in the found feature flag, this method includes targeting check, finding the according variation exposed to the visitor and saving it to storage along with sending tracking request
      * @param {GetFeatureFlagVariableParamsType} parameters - an object with parameters of a type `GetFeatureFlagVariableParamsType`, see the type for details.
      * @returns {FeatureVariableResultType} a variable object containing `type` and `value` fields, `type` can be checked against `FeatureVariableType` enum, if the `type` is `FeatureVariableType.BOOLEAN` then the `value` type will be `boolean` and so on.
      * @throws `KameleoonError` with one of the following `type` s:
@@ -137,7 +147,7 @@ export interface IKameleoonClient {
      * - `KameleoonException.NotTargeted` - Current visitor is not targeted
      * - `KameleoonException.JSONParse` - Couldn't pass JSON value
      * - `KameleoonException.NumberParse` - Couldn't pass Number value
-     * */
+     */
     getFeatureFlagVariable: ({ visitorCode, featureKey, variableKey, }: GetFeatureFlagVariableParamsType) => FeatureVariableResultType;
     /**
      * @method getRemoteData - returns a data which is stored for specified siteCode on a remote Kameleoon server.
@@ -146,7 +156,7 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.RemoteData` - Couldn't retrieve data from Kameleoon server
-     * */
+     */
     getRemoteData: (key: string) => Promise<JSONType>;
     /**
      * @method onConfigurationUpdate - fires a callback on client configuration update. Note: this method only works for server sent events of real time update.
@@ -155,19 +165,20 @@ export interface IKameleoonClient {
      * @throws `KameleoonError` with one of the following `type` s:
      *
      * - `KameleoonException.Initialization` - Method was executed before `initialize` was done for `kameleoonClient`
-     * */
+     */
     onConfigurationUpdate: (callback: () => void) => void;
 }
 /**
  * @class
  * KameleoonClient - a class for creating kameleoon client instance
  * for communicating with Kameleoon JavaScript SDK Core, when new instance is created
- * */
+ */
 export declare class KameleoonClient implements IKameleoonClient {
     private internalConfiguration;
     private variationConfiguration?;
     private campaignConfiguration?;
     private settings;
+    private trackingCache;
     private requester;
     /**
      * @param {SDKCoreParameters} sdkCoreParameters - parameters for initializing sdk core
@@ -180,6 +191,7 @@ export declare class KameleoonClient implements IKameleoonClient {
     flushData(visitorCode: string): void;
     getExperiments(): ExperimentType[];
     getVisitorExperiments(visitorCode: string, isActive?: boolean): ExperimentType[];
+    getExperimentVariationData(variationId: number): JSONType;
     getFeatureFlags(): FeatureFlagType[];
     getVisitorFeatureFlags(visitorCode: string): FeatureFlagType[];
     getFeatureFlagVariationKey(visitorCode: string, featureKey: string): string;
@@ -187,5 +199,6 @@ export declare class KameleoonClient implements IKameleoonClient {
     isFeatureFlagActive(visitorCode: string, featureKey: string): boolean;
     getRemoteData(key: string): Promise<JSONType>;
     onConfigurationUpdate(callback: () => void): void;
+    protected _getEngineTrackingCode(visitorCode: string): string;
     private _getFeatureFlagVariation;
 }