@contentstack/cli-variants 0.0.1-alpha

package/lib/utils/adapter-helper.d.ts

@@ -0,0 +1,30 @@
+import { HttpClientOptions } from '@contentstack/cli-utilities';
+import messages, { $t } from '../messages';
+import { APIConfig, AdapterHelperInterface } from '../types';
+export declare class AdapterHelper<C, ApiClient> implements AdapterHelperInterface<C, ApiClient> {
+    readonly adapterConfig: APIConfig;
+    readonly config: C;
+    readonly $t: typeof $t;
+    readonly apiClient: ApiClient;
+    readonly cmaAPIClient?: ApiClient;
+    readonly messages: typeof messages;
+    constructor(adapterConfig: APIConfig, options?: HttpClientOptions);
+    /**
+     * The function constructs a query string from a given object by encoding its key-value pairs.
+     * @param query - It looks like you have a function `constructQuery` that takes a query object as a
+     * parameter. The function loops through the keys in the query object and constructs a query string
+     * based on the key-value pairs.
+     * @returns The `constructQuery` function returns a string that represents the query parameters
+     * constructed from the input `query` object. If the `query` object is empty (has no keys), the
+     * function does not return anything (void).
+     */
+    constructQuery(query: Record<string, any>): string | void;
+    /**
+     * The `delay` function in TypeScript returns a Promise that resolves after a specified number of
+     * milliseconds.
+     * @param {number} ms - The `ms` parameter represents the number of milliseconds for which the delay
+     * should occur before the `Promise` is resolved.
+     * @returns A Promise that resolves after the specified delay in milliseconds.
+     */
+    delay(ms: number): Promise<void>;
+}

package/lib/utils/adapter-helper.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdapterHelper = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const messages_1 = __importStar(require("../messages"));
+class AdapterHelper {
+    constructor(adapterConfig, options) {
+        this.adapterConfig = adapterConfig;
+        this.$t = messages_1.$t;
+        this.messages = messages_1.default;
+        this.config = adapterConfig.config;
+        delete this.adapterConfig.config;
+        const pickConfig = [
+            'url',
+            'auth',
+            'method',
+            'baseURL',
+            'headers',
+            'adapter',
+            'httpAgent',
+            'httpsAgent',
+            'responseType',
+        ];
+        this.apiClient = new cli_utilities_1.HttpClient((0, pick_1.default)(adapterConfig, pickConfig), options);
+        if (adapterConfig.cmaConfig) {
+            this.cmaAPIClient = new cli_utilities_1.HttpClient((0, pick_1.default)(adapterConfig.cmaConfig, pickConfig), options);
+        }
+    }
+    /**
+     * The function constructs a query string from a given object by encoding its key-value pairs.
+     * @param query - It looks like you have a function `constructQuery` that takes a query object as a
+     * parameter. The function loops through the keys in the query object and constructs a query string
+     * based on the key-value pairs.
+     * @returns The `constructQuery` function returns a string that represents the query parameters
+     * constructed from the input `query` object. If the `query` object is empty (has no keys), the
+     * function does not return anything (void).
+     */
+    constructQuery(query) {
+        if (Object.keys(query).length) {
+            let queryParam = '';
+            for (const key in query) {
+                if (Object.prototype.hasOwnProperty.call(query, key)) {
+                    const element = query[key];
+                    switch (typeof element) {
+                        case 'boolean':
+                            queryParam = queryParam.concat(key);
+                            break;
+                        default:
+                            queryParam = queryParam.concat(`&${key}=${encodeURIComponent(element)}`);
+                            break;
+                    }
+                }
+            }
+            return queryParam;
+        }
+    }
+    /**
+     * The `delay` function in TypeScript returns a Promise that resolves after a specified number of
+     * milliseconds.
+     * @param {number} ms - The `ms` parameter represents the number of milliseconds for which the delay
+     * should occur before the `Promise` is resolved.
+     * @returns A Promise that resolves after the specified delay in milliseconds.
+     */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms <= 0 ? 0 : ms));
+    }
+}
+exports.AdapterHelper = AdapterHelper;

package/lib/utils/attributes-helper.d.ts

@@ -0,0 +1,7 @@
+/**
+ * function to either modify the UID or eliminate it if the attribute is not created in the target project
+ * @param attributeRules
+ * @param attributesUid - {attributesUid} attributes mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+export declare const lookUpAttributes: (attributeRules: Record<string, any>[], attributesUid: Record<string, string>) => Record<string, any>[];

package/lib/utils/attributes-helper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookUpAttributes = void 0;
+/**
+ * function to either modify the UID or eliminate it if the attribute is not created in the target project
+ * @param attributeRules
+ * @param attributesUid - {attributesUid} attributes mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+const lookUpAttributes = (attributeRules, attributesUid) => {
+    var _a;
+    for (let index = 0; index < (attributeRules === null || attributeRules === void 0 ? void 0 : attributeRules.length); index++) {
+        const rule = attributeRules[index];
+        if (rule['__type'] === 'Rule') {
+            // Check if attribute reference exists in attributesUid
+            const attributeRef = (_a = rule.attribute) === null || _a === void 0 ? void 0 : _a.ref;
+            const attributeType = rule.attribute['__type'];
+            // check if type is UserAttributeReference
+            if (attributeType === 'UserAttributeReference') {
+                if (attributeRef && attributesUid.hasOwnProperty(attributeRef) && attributesUid[attributeRef]) {
+                    rule.attribute.ref = attributesUid[attributeRef];
+                }
+                else {
+                    // Remove the rule if the attribute reference is not found
+                    attributeRules.splice(index, 1);
+                    --index;
+                }
+            }
+        }
+        else if (rule['__type'] === 'RuleCombination' && Array.isArray(rule.rules)) {
+            // Recursively look up attributes in nested rule combinations
+            (0, exports.lookUpAttributes)(rule.rules, attributesUid);
+        }
+    }
+    return attributeRules;
+};
+exports.lookUpAttributes = lookUpAttributes;

package/lib/utils/audiences-helper.d.ts

@@ -0,0 +1,8 @@
+import { CreateExperienceInput } from '../types';
+/**
+ * function to either modify the UID or eliminate it if the audience is not created in the target project
+ * @param experience - experience object
+ * @param audiencesUid - {audiencesUid} audiences mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+export declare const lookUpAudiences: (experience: CreateExperienceInput, audiencesUid: Record<string, string>) => CreateExperienceInput;

package/lib/utils/audiences-helper.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookUpAudiences = void 0;
+/**
+ * function for substituting an old audience UID with a new one or deleting the audience information if it does not exist
+ * @param audiences - {audiences} list of audience
+ * @param audiencesUid - {audiencesUid} audiences mapper data in format {<old-uid>: <new-uid>}
+ */
+function updateAudiences(audiences, audiencesUid) {
+    for (let audienceIndex = audiences.length - 1; audienceIndex >= 0; audienceIndex--) {
+        const audienceUid = audiences[audienceIndex];
+        if (audiencesUid.hasOwnProperty(audienceUid) && audiencesUid[audienceUid]) {
+            audiences[audienceIndex] = audiencesUid[audienceUid];
+        }
+        else {
+            audiences.splice(audienceIndex, 1);
+        }
+    }
+}
+/**
+ * function to either modify the UID or eliminate it if the audience is not created in the target project
+ * @param experience - experience object
+ * @param audiencesUid - {audiencesUid} audiences mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+const lookUpAudiences = (experience, audiencesUid) => {
+    var _a, _b, _c, _d, _e, _f;
+    // Update experience variations
+    if ((_a = experience === null || experience === void 0 ? void 0 : experience.variations) === null || _a === void 0 ? void 0 : _a.length) {
+        for (let index = experience.variations.length - 1; index >= 0; index--) {
+            const expVariations = experience.variations[index];
+            if (expVariations['__type'] === 'AudienceBasedVariation' && ((_b = expVariations === null || expVariations === void 0 ? void 0 : expVariations.audiences) === null || _b === void 0 ? void 0 : _b.length)) {
+                updateAudiences(expVariations.audiences, audiencesUid);
+                if (!expVariations.audiences.length) {
+                    experience.variations.splice(index, 1);
+                }
+            }
+        }
+    }
+    // Update targeting audiences
+    if (((_c = experience === null || experience === void 0 ? void 0 : experience.targeting) === null || _c === void 0 ? void 0 : _c.hasOwnProperty('audience')) && ((_f = (_e = (_d = experience === null || experience === void 0 ? void 0 : experience.targeting) === null || _d === void 0 ? void 0 : _d.audience) === null || _e === void 0 ? void 0 : _e.audiences) === null || _f === void 0 ? void 0 : _f.length)) {
+        updateAudiences(experience.targeting.audience.audiences, audiencesUid);
+        if (!experience.targeting.audience.audiences.length) {
+            experience.targeting = {};
+        }
+    }
+    return experience;
+};
+exports.lookUpAudiences = lookUpAudiences;

package/lib/utils/error-helper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Formats the errors into a single string.
+ * @param errors - The errors to be formatted.
+ * @returns The formatted errors as a string.
+ */
+export declare function formatErrors(errors: any): string;

package/lib/utils/error-helper.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatErrors = formatErrors;
+/**
+ * Formats the errors into a single string.
+ * @param errors - The errors to be formatted.
+ * @returns The formatted errors as a string.
+ */
+function formatErrors(errors) {
+    const errorMessages = [];
+    for (const errorKey in errors) {
+        const errorValue = errors[errorKey];
+        if (Array.isArray(errorValue)) {
+            errorMessages.push(...errorValue.map((error) => formatError(error)));
+        }
+        else {
+            errorMessages.push(formatError(errorValue));
+        }
+    }
+    return errorMessages.join(' ');
+}
+function formatError(error) {
+    if (typeof error === 'object') {
+        return Object.values(error).join(' ');
+    }
+    return String(error);
+}

package/lib/utils/events-helper.d.ts

@@ -0,0 +1,8 @@
+import { CreateExperienceInput } from '../types';
+/**
+ * function to either modify the UID or eliminate it if the event is not created in the target project
+ * @param experience - experience object
+ * @param eventsUid - {eventsUid} events mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+export declare const lookUpEvents: (experience: CreateExperienceInput, eventsUid: Record<string, string>) => CreateExperienceInput;

package/lib/utils/events-helper.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookUpEvents = void 0;
+/**
+ * function to either modify the UID or eliminate it if the event is not created in the target project
+ * @param experience - experience object
+ * @param eventsUid - {eventsUid} events mapper data in format {<old-uid>: <new-uid>}
+ * @returns
+ */
+const lookUpEvents = (experience, eventsUid) => {
+    var _a, _b;
+    // Update events uid in experience metrics
+    if ((_a = experience === null || experience === void 0 ? void 0 : experience.metrics) === null || _a === void 0 ? void 0 : _a.length) {
+        for (let metricIndex = ((_b = experience === null || experience === void 0 ? void 0 : experience.metrics) === null || _b === void 0 ? void 0 : _b.length) - 1; metricIndex >= 0; metricIndex--) {
+            const metric = experience === null || experience === void 0 ? void 0 : experience.metrics[metricIndex];
+            const eventUid = metric.event;
+            if (eventsUid.hasOwnProperty(eventUid) && eventsUid[eventUid]) {
+                experience.metrics[metricIndex].event = eventsUid[eventUid];
+            }
+            else {
+                experience === null || experience === void 0 ? void 0 : experience.metrics.splice(metricIndex, 1);
+            }
+        }
+    }
+    return experience;
+};
+exports.lookUpEvents = lookUpEvents;

package/lib/utils/helper.d.ts

@@ -0,0 +1,4 @@
+import { FsUtility } from '@contentstack/cli-utilities';
+export declare const formatError: (error: any) => any;
+export declare const fsUtil: FsUtility;
+export declare const askProjectName: (defaultValue: unknown) => Promise<string>;

package/lib/utils/helper.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askProjectName = exports.fsUtil = exports.formatError = void 0;
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const formatError = function (error) {
+    try {
+        if (typeof error === 'string') {
+            error = JSON.parse(error);
+        }
+        else {
+            error = JSON.parse(error.message);
+        }
+    }
+    catch (e) { }
+    let message = error.errorMessage || error.error_message || error.message || error;
+    if (error.errors && Object.keys(error.errors).length > 0) {
+        Object.keys(error.errors).forEach((e) => {
+            let entity = e;
+            if (e === 'authorization')
+                entity = 'Management Token';
+            if (e === 'api_key')
+                entity = 'Stack API key';
+            if (e === 'uid')
+                entity = 'Content Type';
+            if (e === 'access_token')
+                entity = 'Delivery Token';
+            message += ' ' + [entity, error.errors[e]].join(' ');
+        });
+    }
+    return message;
+};
+exports.formatError = formatError;
+exports.fsUtil = new cli_utilities_1.FsUtility();
+const askProjectName = (defaultValue) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield cli_utilities_1.cliux.inquire({
+        type: 'input',
+        name: 'name',
+        default: defaultValue,
+        message: 'Enter the project name:',
+    });
+});
+exports.askProjectName = askProjectName;

package/lib/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './adapter-helper';
+export * from './variant-api-adapter';
+export * from './personalization-api-adapter';
+export * from './logger';
+export * from './helper';
+export * from './attributes-helper';
+export * from './audiences-helper';
+export * from './events-helper';
+export * from './error-helper';

package/lib/utils/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapter-helper"), exports);
+__exportStar(require("./variant-api-adapter"), exports);
+__exportStar(require("./personalization-api-adapter"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./helper"), exports);
+__exportStar(require("./attributes-helper"), exports);
+__exportStar(require("./audiences-helper"), exports);
+__exportStar(require("./events-helper"), exports);
+__exportStar(require("./error-helper"), exports);

package/lib/utils/logger.d.ts

@@ -0,0 +1,3 @@
+import { ExportConfig, ImportConfig } from '../types';
+export declare const log: (config: ExportConfig | ImportConfig, message: any, type: "info" | "error" | "success") => void;
+export declare const unlinkFileLogger: () => void;

package/lib/utils/logger.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unlinkFileLogger = exports.log = void 0;
+const winston = __importStar(require("winston"));
+const path = __importStar(require("path"));
+const mkdirp_1 = __importDefault(require("mkdirp"));
+const cli_utilities_1 = require("@contentstack/cli-utilities");
+const slice = Array.prototype.slice;
+const ansiRegexPattern = [
+    '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+    '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))',
+].join('|');
+function returnString(args) {
+    let returnStr = '';
+    if (args && args.length) {
+        returnStr = args
+            .map(function (item) {
+            if (item && typeof item === 'object') {
+                try {
+                    return JSON.stringify(item).replace(/authtoken\":\d"blt................/g, 'authtoken":"blt....');
+                }
+                catch (error) { }
+                return item;
+            }
+            return item;
+        })
+            .join('  ')
+            .trim();
+    }
+    returnStr = returnStr.replace(new RegExp(ansiRegexPattern, 'g'), '').trim();
+    return returnStr;
+}
+const myCustomLevels = {
+    levels: {
+        warn: 1,
+        info: 2,
+        debug: 3,
+    },
+    colors: {
+        //colors aren't being used anywhere as of now, we're using chalk to add colors while logging
+        info: 'blue',
+        debug: 'green',
+        warn: 'yellow',
+        error: 'red',
+    },
+};
+let logger;
+let errorLogger;
+let successTransport;
+let errorTransport;
+function init(_logPath) {
+    if (!logger || !errorLogger) {
+        const logsDir = path.resolve((0, cli_utilities_1.sanitizePath)(_logPath), 'logs', 'export');
+        // Create dir if doesn't already exist
+        mkdirp_1.default.sync(logsDir);
+        successTransport = {
+            filename: path.join((0, cli_utilities_1.sanitizePath)(logsDir), 'success.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'info',
+        };
+        errorTransport = {
+            filename: path.join((0, cli_utilities_1.sanitizePath)(logsDir), 'error.log'),
+            maxFiles: 20,
+            maxsize: 1000000,
+            tailable: true,
+            level: 'error',
+        };
+        logger = winston.createLogger({
+            transports: [
+                new winston.transports.File(successTransport),
+                new winston.transports.Console({ format: winston.format.simple() }),
+            ],
+            levels: myCustomLevels.levels,
+        });
+        errorLogger = winston.createLogger({
+            transports: [
+                new winston.transports.File(errorTransport),
+                new winston.transports.Console({
+                    level: 'error',
+                    format: winston.format.combine(winston.format.colorize({ all: true, colors: { error: 'red' } }), winston.format.simple()),
+                }),
+            ],
+            levels: { error: 0 },
+        });
+    }
+    return {
+        log: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('info', logString);
+            }
+        },
+        warn: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('warn', logString);
+            }
+        },
+        error: function (message) {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                errorLogger.log('error', logString);
+            }
+        },
+        debug: function () {
+            const args = slice.call(arguments);
+            const logString = returnString(args);
+            if (logString) {
+                logger.log('debug', logString);
+            }
+        },
+    };
+}
+const log = (config, message, type) => {
+    const logsPath = config.data;
+    // ignoring the type argument, as we are not using it to create a logfile anymore
+    if (type !== 'error') {
+        // removed type argument from init method
+        init(logsPath).log(message);
+    }
+    else {
+        init(logsPath).error(message);
+    }
+};
+exports.log = log;
+const unlinkFileLogger = () => {
+    if (logger) {
+        const transports = logger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                logger.remove(transport);
+            }
+        });
+    }
+    if (errorLogger) {
+        const transports = errorLogger.transports;
+        transports.forEach((transport) => {
+            if (transport.name === 'file') {
+                errorLogger.remove(transport);
+            }
+        });
+    }
+};
+exports.unlinkFileLogger = unlinkFileLogger;

package/lib/utils/personalization-api-adapter.d.ts

@@ -0,0 +1,73 @@
+import { AdapterHelper } from './adapter-helper';
+import { HttpClient } from '@contentstack/cli-utilities';
+import { ProjectStruct, Personalization, GetProjectsParams, CreateProjectInput, CreateAttributeInput, APIConfig, GetVariantGroupInput, EventStruct, AudienceStruct, AttributeStruct, CreateAudienceInput, CreateEventInput, CreateExperienceInput, ExperienceStruct, UpdateExperienceInput, CMSExperienceStruct, VariantAPIRes, APIResponse, VariantGroupStruct, VariantGroup } from '../types';
+export declare class PersonalizationAdapter<T> extends AdapterHelper<T, HttpClient> implements Personalization<T> {
+    constructor(options: APIConfig);
+    projects(options: GetProjectsParams): Promise<ProjectStruct[]>;
+    /**
+     * This TypeScript function creates a project by making an asynchronous API call to retrieve project
+     * data.
+     * @param {CreateProjectInput} input - The `input` parameter in the `createProject` function likely
+     * represents the data needed to create a new project. It could include details such as the project
+     * name, description, owner, deadline, or any other relevant information required to set up a new
+     * project.
+     * @returns The `createProject` function is returning a Promise that resolves to either a
+     * `ProjectStruct` object or `void`.
+     */
+    createProject(project: CreateProjectInput): Promise<ProjectStruct>;
+    /**
+     * The function `createAttribute` asynchronously retrieves attribute data from an API endpoint.
+     * @param {CreateAttributeInput} input - The `input` parameter in the `createAttribute` function is
+     * of type `CreateAttributeInput`. This parameter likely contains the necessary data or information
+     * needed to create a new attribute.
+     * @returns The `createAttribute` function is returning the data obtained from a GET request to the
+     * `/attributes` endpoint using the `apiClient` with the input provided. The data returned is of type
+     * `ProjectStruct`.
+     */
+    createAttribute(attribute: CreateAttributeInput): Promise<AttributeStruct>;
+    getExperiences(): Promise<ExperienceStruct[]>;
+    getExperience(experienceUid: string): Promise<ExperienceStruct | void>;
+    getVariantGroup(input: GetVariantGroupInput): Promise<VariantGroupStruct | void>;
+    updateVariantGroup(input: VariantGroup): Promise<VariantGroup | void>;
+    getEvents(): Promise<EventStruct[] | void>;
+    createEvents(event: CreateEventInput): Promise<void | EventStruct>;
+    getAudiences(): Promise<AudienceStruct[] | void>;
+    getAttributes(): Promise<AttributeStruct[] | void>;
+    /**
+     * @param {CreateAudienceInput} audience - The `audience` parameter in the `createAudience` function is
+     * of type `CreateAudienceInput`. This parameter likely contains the necessary data or information
+     * needed to create a new audience.
+     * @returns The `createAudience` function is returning the data obtained from a GET request to the
+     * `/audiences` endpoint using the `apiClient` with the input provided. The data returned is of type
+     * `AudienceStruct`.
+     */
+    createAudience(audience: CreateAudienceInput): Promise<void | AudienceStruct>;
+    /**
+     * @param {CreateExperienceInput} experience - The `experience` parameter in the `createExperience` function is
+     * of type `CreateExperienceInput`. This parameter likely contains the necessary data or information
+     * needed to create a new audience.
+     * @returns The `createExperience` function is returning the data obtained from a GET request to the
+     * `/experiences` endpoint using the `apiClient` with the input provided. The data returned is of type
+     * `ExperienceStruct`.
+     */
+    createExperience(experience: CreateExperienceInput): Promise<void | ExperienceStruct>;
+    /**
+     * @param {UpdateExperienceInput} experience - The `experience` parameter in the `updateCTsInExperience` function is
+     * of type `UpdateExperienceInput`. This parameter likely contains the necessary data or information
+     * needed to attach CT in new created experience.
+     */
+    updateCTsInExperience(experience: UpdateExperienceInput, experienceUid: string): Promise<void | CMSExperienceStruct>;
+    /**
+     * @param {UpdateExperienceInput} experienceUid - The `experienceUid` parameter in the `getCTsFromExperience` function is
+     * of type `string`. This parameter likely contains the necessary data or information
+     * needed to fetch CT details related to experience.
+     */
+    getCTsFromExperience(experienceUid: string): Promise<void | CMSExperienceStruct>;
+    /**
+     * Handles the API response for variant requests.
+     * @param res - The API response object.
+     * @returns The variant API response data.
+     * @throws If the API response status is not within the success range, an error message is thrown.
+     */
+    handleVariantAPIRes(res: APIResponse): VariantAPIRes;
+}