@kameleoon/javascript-sdk-core 0.0.3 → 1.1.0

package/dist/types.d.ts

@@ -1,5 +1,135 @@
-declare type JSONValue = string | number | boolean | {
-    [x: string]: JSONValue;
-} | JSONValue[];
-export declare type CustomJsonType = Record<string | number | symbol, JSONValue> | null;
-export {};
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { JSONType } from './campaignConfiguration/types';
+import { IExternalEventSourceConstructor } from './eventSource';
+import { IExternalStorageConstructor } from './storage';
+/**
+ * @param {number} updateInterval - update interval in _minutes_ for sdk configuration, minimum value is 1 minute
+ * @defaultvalue 60
+ *
+ * @param {Environment} environment - feature flag environment
+ * @defaultvalue Environment.Production
+ * */
+export type SDKConfigurationType = {
+    updateInterval?: number;
+    environment?: Environment;
+};
+/**
+ * @param {string} siteCode - client's siteCode defined on Kameleoon platform
+ * @param {Partial<SDKConfigurationType>} configuration - client's configuration
+ * @param {InternalSDKConfigurationType} internalConfiguration - internal configuration for sdk core to be initialized with certain parameters to certain type of JavaScript SDK
+ * */
+export type SDKCoreParameters = {
+    siteCode: string;
+    configuration?: Partial<SDKConfigurationType>;
+    internalConfiguration: InternalSDKConfigurationType;
+};
+/**
+ * @param {IExternalStorage | undefiend} externalStorage - external file system storage implemented outside client initialization
+ * @param {IExternalEventSourceConstructor | undefiend} externalEventSource - constructor for building external event source implementation
+ * */
+export type InternalSDKConfigurationType = {
+    externalStorage: IExternalStorageConstructor;
+    externalEventSource: IExternalEventSourceConstructor;
+};
+/**
+ * @readonly
+ * @enum {string} an Enum containing all possible variants of environment, passed as an argument to KameleoonClient `configuration`s `environment` field
+ * */
+export declare enum Environment {
+    Production = "production",
+    Staging = "staging",
+    Development = "development"
+}
+/**
+ * @readonly
+ * @enum {string} an Enum containing all possible variants of feature variable types
+ * */
+export declare enum VariableType {
+    BOOLEAN = "BOOLEAN",
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    JSON = "JSON"
+}
+export type BooleanVariableType = {
+    type: VariableType.BOOLEAN;
+    value: boolean;
+};
+export type NumberVariableType = {
+    type: VariableType.NUMBER;
+    value: number;
+};
+export type StringVariableType = {
+    type: VariableType.STRING;
+    value: string;
+};
+export type JSONVariableType = {
+    type: VariableType.JSON;
+    value: JSONType;
+};
+/**
+ * @type FeatureVariableResultType - tuple of possible feature variable result types, each possible variation is an 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.
+ * */
+export type FeatureVariableResultType = BooleanVariableType | NumberVariableType | StringVariableType | JSONVariableType;
+export declare enum Milliseconds {
+    Second = 1000,
+    Minute = 60000,
+    Hour = 3600000
+}
+export type TrackConversionParamsType = {
+    visitorCode: string;
+    goalId: number;
+    revenue: number;
+};
+export type ExperimentType = {
+    id: number;
+    name: string;
+};
+export type FeatureFlagType = {
+    id: number;
+    key: string;
+};
+/**
+ * @param {string} visitorCode - unique visitor identifier, shouldn't exceed 255 characters
+ * @param {string} featureKey - key of the feature flag to look for, can be found on Kameleoon Platform
+ * @param {string} variableKey - key of the variable to be found for a feature flag with provided `featureKey`, can be found on Kameleoon Platform
+ * */
+export type GetFeatureFlagVariableParamsType = {
+    visitorCode: string;
+    featureKey: string;
+    variableKey: string;
+};
+/**
+ * @param {string} domain - domain which cookie belongs to
+ * @param {string} visitorCode - unique visitor identifier, shouldn't exceed 255 characters
+ * */
+export type GetResultCookieParametersType = {
+    domain: string;
+    visitorCode: string;
+};
+/**
+ * @param {Request} request - request object to get the cookie from
+ * @param {Response} response - response object to write the updated cookie to
+ * @param {string} domain - domain which cookie belongs to
+ * @param {string | undefined} defaultVisitorCode - visitor code to be used in case there is no visitor code in cookies *Note*: if not passed visitor code will be randomly generated
+ * */
+export type ServerGetVisitorCodeParametersType = {
+    request: IncomingMessage;
+    response: ServerResponse;
+    domain: string;
+    defaultVisitorCode?: string;
+};
+/**
+ * @param {string} domain - domain which cookie belongs to
+ * @param {string | undefined} defaultVisitorCode - visitor code to be used in case there is no visitor code in cookies *Note*: if not passed visitor code will be randomly generated
+ * */
+export type ClientGetVisitorCodeParametersType = {
+    domain: string;
+    defaultVisitorCode?: string;
+};
+/**
+ * @param {string | undefined} defaultVisitorCode - visitor code to be used in case there is no visitor code in cookies *Note*: if not passed visitor code will be randomly generated
+ * */
+export type MobileGetVisitorCodeParametersType = {
+    defaultVisitorCode?: string;
+};

package/dist/types.js

@@ -1,3 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Milliseconds = exports.VariableType = exports.Environment = void 0;
+/**
+ * @readonly
+ * @enum {string} an Enum containing all possible variants of environment, passed as an argument to KameleoonClient `configuration`s `environment` field
+ * */
+var Environment;
+(function (Environment) {
+    Environment["Production"] = "production";
+    Environment["Staging"] = "staging";
+    Environment["Development"] = "development";
+})(Environment = exports.Environment || (exports.Environment = {}));
+/**
+ * @readonly
+ * @enum {string} an Enum containing all possible variants of feature variable types
+ * */
+var VariableType;
+(function (VariableType) {
+    VariableType["BOOLEAN"] = "BOOLEAN";
+    VariableType["NUMBER"] = "NUMBER";
+    VariableType["STRING"] = "STRING";
+    VariableType["JSON"] = "JSON";
+})(VariableType = exports.VariableType || (exports.VariableType = {}));
+var Milliseconds;
+(function (Milliseconds) {
+    Milliseconds[Milliseconds["Second"] = 1000] = "Second";
+    Milliseconds[Milliseconds["Minute"] = 60000] = "Minute";
+    Milliseconds[Milliseconds["Hour"] = 3600000] = "Hour";
+})(Milliseconds = exports.Milliseconds || (exports.Milliseconds = {}));
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAqCA;;;KAGK;AACL,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,wCAAyB,CAAA;IACzB,kCAAmB,CAAA;IACnB,0CAA2B,CAAA;AAC7B,CAAC,EAJW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAItB;AAED;;;KAGK;AACL,IAAY,YAKX;AALD,WAAY,YAAY;IACtB,mCAAmB,CAAA;IACnB,iCAAiB,CAAA;IACjB,iCAAiB,CAAA;IACjB,6BAAa,CAAA;AACf,CAAC,EALW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAKvB;AAmBD,IAAY,YAIX;AAJD,WAAY,YAAY;IACtB,sDAAa,CAAA;IACb,uDAAiC,CAAA;IACjC,qDAA+B,CAAA;AACjC,CAAC,EAJW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAIvB"}

package/dist/utilities/constants.d.ts

@@ -0,0 +1 @@
+export declare const VISITOR_CODE_MAX_LENGTH = 255;

package/dist/utilities/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VISITOR_CODE_MAX_LENGTH = void 0;
+exports.VISITOR_CODE_MAX_LENGTH = 255;
+//# sourceMappingURL=constants.js.map

package/dist/utilities/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/utilities/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,uBAAuB,GAAG,GAAG,CAAC"}

package/dist/utilities/index.d.ts

@@ -0,0 +1 @@
+export { Utilities } from './utilities';

package/dist/utilities/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utilities = void 0;
+var utilities_1 = require("./utilities");
+Object.defineProperty(exports, "Utilities", { enumerable: true, get: function () { return utilities_1.Utilities; } });
+//# sourceMappingURL=index.js.map

package/dist/utilities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utilities/index.ts"],"names":[],"mappings":";;;AAAA,yCAAwC;AAA/B,sGAAA,SAAS,OAAA"}

package/dist/utilities/types.d.ts

@@ -0,0 +1,18 @@
+import { CampaignConfiguration } from '../campaignConfiguration';
+import { Requester } from '../requester';
+import { SegmentType, TargetingDataItemType } from '../targeting';
+import { VariationConfiguration, FeatureFlagVariationType } from '../variationConfiguration';
+export type CheckTargetingParamsType = {
+    segment: SegmentType | null;
+    experimentId: number | null;
+    visitorCode: string;
+    targetingData?: TargetingDataItemType[];
+    variationConfiguration?: VariationConfiguration;
+};
+export type TrackExperimentationRuleParamsType = {
+    featureFlagVariation: FeatureFlagVariationType;
+    campaignConfiguration: CampaignConfiguration;
+    visitorCode: string;
+    requester: Requester;
+    userAgent?: string;
+};

package/dist/utilities/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/utilities/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/utilities/types.ts"],"names":[],"mappings":""}

package/dist/utilities/utilities.d.ts

@@ -0,0 +1,13 @@
+import { Result } from 'ts-res';
+import { KameleoonError } from '../kameleoonError';
+import { CheckTargetingParamsType, TrackExperimentationRuleParamsType } from './types';
+import { FeatureVariableResultType } from '../types';
+import { CampaignConfiguration, FeatureVariableType } from '../campaignConfiguration';
+export declare class Utilities {
+    static checkTargeting({ segment, visitorCode, targetingData, experimentId, variationConfiguration, }: CheckTargetingParamsType): Result<boolean, KameleoonError>;
+    static validateVisitorCode(visitorCode: string): Result<void, KameleoonError>;
+    static getDataUrl(visitorCode: string, campaignConfiguration: CampaignConfiguration): string;
+    static trackExperimentationRule({ featureFlagVariation, campaignConfiguration, visitorCode, requester, userAgent, }: TrackExperimentationRuleParamsType): void;
+    static parseFeatureVariable(variable: FeatureVariableType): Result<FeatureVariableResultType, KameleoonError>;
+    static getUserAgent(visitorCode: string, campaignConfiguration: CampaignConfiguration): string | undefined;
+}

package/dist/utilities/utilities.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utilities = void 0;
+const ts_res_1 = require("ts-res");
+const kameleoonError_1 = require("../kameleoonError");
+const types_1 = require("../types");
+const targeting_1 = require("../targeting");
+const constants_1 = require("./constants");
+const campaignConfiguration_1 = require("../campaignConfiguration");
+const kameleoonData_1 = require("../kameleoonData");
+class Utilities {
+    static checkTargeting({ segment, visitorCode, targetingData, experimentId, variationConfiguration, }) {
+        if (!segment || !segment.conditionsData.firstLevel.length) {
+            return (0, ts_res_1.Ok)(true);
+        }
+        if (!variationConfiguration) {
+            return (0, ts_res_1.Err)(new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.Initialization));
+        }
+        let variations = {};
+        const assignedVariationsResult = variationConfiguration.getAssignedVariations(visitorCode);
+        if (assignedVariationsResult.ok) {
+            variations = assignedVariationsResult.data;
+        }
+        const targetingTree = new targeting_1.TargetingTree(segment);
+        const result = targetingTree.evaluate({
+            targetingData: targetingData || [],
+            variationData: variations,
+            experimentId,
+        });
+        return result;
+    }
+    static validateVisitorCode(visitorCode) {
+        if (visitorCode.length > constants_1.VISITOR_CODE_MAX_LENGTH) {
+            return (0, ts_res_1.Err)(new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.VisitorCodeMaxLength));
+        }
+        return (0, ts_res_1.Ok)();
+    }
+    static getDataUrl(visitorCode, campaignConfiguration) {
+        const unsentData = campaignConfiguration.getUnsentData(visitorCode);
+        const concatenatedUrl = unsentData.reduce((previousItem, currentItem) => {
+            return previousItem + currentItem.url;
+        }, '');
+        return concatenatedUrl;
+    }
+    static trackExperimentationRule({ featureFlagVariation, campaignConfiguration, visitorCode, requester, userAgent, }) {
+        const { variationId, rule } = featureFlagVariation;
+        if (!rule || rule.type !== campaignConfiguration_1.RuleType.EXPERIMENTATION) {
+            throw new Error('Internal usage error, make sure to use `trackExperimentationRule` for existing rule with type `RuleType.EXPERIMENTATION`');
+        }
+        const dataUrl = this.getDataUrl(visitorCode, campaignConfiguration);
+        const resultVariationId = variationId || 0;
+        const isUnallocated = !variationId;
+        const callback = () => campaignConfiguration.clearUnsentData;
+        requester.trackExperiment({
+            visitorCode,
+            isUnallocated,
+            body: dataUrl,
+            callback,
+            // --- Note ---
+            // For `RuleType.EXPERIMENTATION` `experimentId` can not be null
+            experimentId: rule.experimentId,
+            variationId: resultVariationId,
+            userAgent,
+        });
+    }
+    static parseFeatureVariable(variable) {
+        const { type, value } = variable;
+        switch (type) {
+            case types_1.VariableType.BOOLEAN:
+                return (0, ts_res_1.Ok)({
+                    type,
+                    value: Boolean(value),
+                });
+            case types_1.VariableType.STRING:
+                return (0, ts_res_1.Ok)({
+                    type,
+                    value: String(value),
+                });
+            case types_1.VariableType.NUMBER:
+                const numberValue = Number(value);
+                if (Number.isNaN(numberValue)) {
+                    return (0, ts_res_1.Err)(new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.NumberParse, String(value)));
+                }
+                return (0, ts_res_1.Ok)({
+                    type,
+                    value: numberValue,
+                });
+            case types_1.VariableType.JSON:
+                try {
+                    const jsonValue = JSON.parse(String(variable.value));
+                    return (0, ts_res_1.Ok)({
+                        type,
+                        value: jsonValue,
+                    });
+                }
+                catch (err) {
+                    return (0, ts_res_1.Err)(new kameleoonError_1.KameleoonError(kameleoonError_1.KameleoonException.JSONParse, err));
+                }
+            default:
+                (0, kameleoonError_1.exhaustCheck)(type);
+        }
+    }
+    static getUserAgent(visitorCode, campaignConfiguration) {
+        const isUserAgent = (data) => data.type === kameleoonData_1.KameleoonData.UserAgent;
+        const targetingData = campaignConfiguration.storedTargetingData[visitorCode];
+        if (targetingData) {
+            const filteredData = targetingData
+                .map((item) => item.data)
+                .filter(isUserAgent);
+            if (filteredData.length) {
+                const [userAgentData] = filteredData;
+                return userAgentData.value;
+            }
+        }
+        return undefined;
+    }
+}
+exports.Utilities = Utilities;
+//# sourceMappingURL=utilities.js.map

package/dist/utilities/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../src/utilities/utilities.ts"],"names":[],"mappings":"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"}

package/dist/variationConfiguration/index.d.ts

@@ -0,0 +1,2 @@
+export { VariationConfiguration } from './variationConfiguration';
+export { VariationType, FeatureFlagVariationType } from './types';

package/dist/variationConfiguration/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariationConfiguration = void 0;
+var variationConfiguration_1 = require("./variationConfiguration");
+Object.defineProperty(exports, "VariationConfiguration", { enumerable: true, get: function () { return variationConfiguration_1.VariationConfiguration; } });
+//# sourceMappingURL=index.js.map

package/dist/variationConfiguration/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/variationConfiguration/index.ts"],"names":[],"mappings":";;;AAAA,mEAAkE;AAAzD,gIAAA,sBAAsB,OAAA"}

package/dist/variationConfiguration/types.d.ts

@@ -0,0 +1,25 @@
+import { FeatureFlagType, RuleItemType } from '../campaignConfiguration';
+import { TargetingDataItemType } from '../targeting';
+export type VariationType = {
+    variationId: number;
+    assignmentDate: string;
+};
+export type UpdateStorageParamsType = {
+    visitorCode: string;
+    experimentId: string;
+    variationId: number;
+};
+export type FeatureFlagVariationType = {
+    variationKey: string;
+    variationId: number | null;
+    featureFlagId: number;
+    featureKey: string;
+    rule: RuleItemType | null;
+};
+export type GetFeatureFlagVariationParametersType = {
+    visitorCode: string;
+    featureFlag: FeatureFlagType;
+    targetingData?: TargetingDataItemType[];
+    withAssignment?: boolean;
+};
+export type GetAssignedRuleVariationResultType = Pick<FeatureFlagVariationType, 'variationId' | 'variationKey'>;

package/dist/variationConfiguration/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/variationConfiguration/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/variationConfiguration/types.ts"],"names":[],"mappings":""}

package/dist/variationConfiguration/variation.d.ts

@@ -0,0 +1,13 @@
+import { RespoolTimeType } from '../campaignConfiguration/types';
+import { VariationType } from './types';
+interface IVariation {
+    readonly id: number;
+    isValid: (respoolTime?: RespoolTimeType[]) => boolean;
+}
+export declare class Variation implements IVariation {
+    variationData?: VariationType;
+    constructor(variationData?: VariationType);
+    get id(): number;
+    isValid(respoolTime?: RespoolTimeType[]): boolean;
+}
+export {};

package/dist/variationConfiguration/variation.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Variation = void 0;
+const types_1 = require("../types");
+class Variation {
+    constructor(variationData) {
+        this.variationData = variationData;
+    }
+    get id() {
+        if (!this.variationData) {
+            throw new Error("Internal usage error: Check if the variation `isValid`, before getting it's `id`");
+        }
+        return this.variationData.variationId;
+    }
+    isValid(respoolTime) {
+        const variation = this.variationData;
+        if (!variation) {
+            return false;
+        }
+        // --- Note ---
+        // - Respool is a kind of shuffle parameter
+        // it's presence indicates that variations assigned to
+        // user has changed at certain time (time is the value of `respoolTime` in seconds)
+        // - So the variation is valid unless it has been shuffled after it's assignment
+        if (respoolTime === null || respoolTime === void 0 ? void 0 : respoolTime.length) {
+            const assignmentTime = new Date(Date.parse(variation.assignmentDate)).getTime() /
+                types_1.Milliseconds.Second;
+            const variationRespoolTime = respoolTime.find((respool) => respool.variationId === String(variation.variationId));
+            if (!variationRespoolTime) {
+                return true;
+            }
+            return assignmentTime > variationRespoolTime.value;
+        }
+        return true;
+    }
+}
+exports.Variation = Variation;
+//# sourceMappingURL=variation.js.map

package/dist/variationConfiguration/variation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variation.js","sourceRoot":"","sources":["../../src/variationConfiguration/variation.ts"],"names":[],"mappings":";;;AACA,oCAAwC;AAQxC,MAAa,SAAS;IAGpB,YAAY,aAA6B;QACvC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;IAED,IAAI,EAAE;QACJ,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,MAAM,IAAI,KAAK,CACb,kFAAkF,CACnF,CAAC;SACH;QAED,OAAO,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC;IACxC,CAAC;IAEM,OAAO,CAAC,WAA+B;QAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC;QAErC,IAAI,CAAC,SAAS,EAAE;YACd,OAAO,KAAK,CAAC;SACd;QAED,eAAe;QACf,2CAA2C;QAC3C,sDAAsD;QACtD,mFAAmF;QACnF,gFAAgF;QAChF,IAAI,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,MAAM,EAAE;YACvB,MAAM,cAAc,GAClB,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,OAAO,EAAE;gBACxD,oBAAY,CAAC,MAAM,CAAC;YACtB,MAAM,oBAAoB,GAAG,WAAW,CAAC,IAAI,CAC3C,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,KAAK,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,CACnE,CAAC;YAEF,IAAI,CAAC,oBAAoB,EAAE;gBACzB,OAAO,IAAI,CAAC;aACb;YAED,OAAO,cAAc,GAAG,oBAAoB,CAAC,KAAK,CAAC;SACpD;QAED,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AA9CD,8BA8CC"}

package/dist/variationConfiguration/variationConfiguration.d.ts

@@ -0,0 +1,36 @@
+import { Result } from 'ts-res';
+import { ExperimentItemType } from '../campaignConfiguration';
+import { KameleoonError } from '../kameleoonError';
+import { IStorage, VariationDataType, ExperimentVariationsType } from '../storage';
+import { FeatureFlagVariationType, GetFeatureFlagVariationParametersType } from './types';
+interface IVariationConfiguration {
+    /**
+     * @method getAssociatedVariationId - gets the id of a variation assigned to a visitor with `visitorCode` from the storage. If the visitor doesn't have associated variation yet, assigns a new one, stores it and returns it's id.
+     * */
+    getAssociatedVariationId: (visitorCode: string, experimentId: number) => Result<number, KameleoonError>;
+    /**
+     * @method getAssignedVariations - obtains experiments with according variations that are *already assigned* and *stored* in the `variationStorage`. If `getAssociatedVariationId` hadn't been called before, there will be no variations to get.
+     * */
+    getAssignedVariations(visitorCode: string): Result<ExperimentVariationsType, KameleoonError>;
+    /**
+     * @method getFeatureFlagVariation - obtains variation for the rule of the feature flag which is both targeted and has a variation, if no such rule was found, returns empty rule with default `variationKey`, given an option `withAssignment` of `true` will also assign a new variation and save it in the storage
+     * */
+    getFeatureFlagVariation: (params: GetFeatureFlagVariationParametersType) => Result<FeatureFlagVariationType, KameleoonError>;
+    /**
+     * @method getExperimentVariation - obtains variation for the experiment by calculating the variation for the visitor *without assigning* it to a visitor
+     * */
+    getExperimentVariation: (visitorCode: string, experiment: ExperimentItemType) => Result<number, KameleoonError>;
+}
+export declare class VariationConfiguration implements IVariationConfiguration {
+    private experiments;
+    private storage;
+    constructor(experiments: ExperimentItemType[], externalStorage: IStorage<VariationDataType>);
+    getAssociatedVariationId: (visitorCode: string, experimentId: number) => Result<number, KameleoonError>;
+    getAssignedVariations(visitorCode: string): Result<ExperimentVariationsType, KameleoonError>;
+    getFeatureFlagVariation({ visitorCode, featureFlag, targetingData, withAssignment, }: GetFeatureFlagVariationParametersType): Result<FeatureFlagVariationType, KameleoonError>;
+    getExperimentVariation(visitorCode: string, experiment: ExperimentItemType): Result<number, KameleoonError>;
+    private assignVariation;
+    private updateStorageData;
+    private getAssignedRuleVariation;
+}
+export {};