@hcl-software/dxclient 221.0.0

package/dist/src/services/apiServices.js

@@ -0,0 +1,932 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiServices = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const lodash_1 = require("lodash");
+const urlencode_1 = __importDefault(require("urlencode"));
+const constants_1 = require("../utils/constants");
+const logger_1 = require("../utils/logger");
+const filesServices_1 = require("./filesServices");
+const utils_1 = require("../utils/utils");
+const requestService_1 = require("./requestService");
+const MaskData = require('maskdata');
+const uploadFileToServer = (uploadFileUrl, filePath, serverUsername, serverPassword) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the uploadFileToServer function.');
+    logger_1.logger.debug('File path of the local file %s', filePath);
+    logger_1.logger.debug('Upload file url %s', uploadFileUrl);
+    let fileSize;
+    try {
+        fileSize = fs_extra_1.default.statSync(filePath).size + constants_1.REQUEST_BUFFER;
+        const file = fs_extra_1.default.createReadStream(filePath);
+        const formData = new form_data_1.default();
+        formData.append('file', file);
+        const headers = {
+            headers: Object.assign({ 'Content-Type': 'multipart/form-data', Authorization: utils_1.baseEncode(serverUsername, serverPassword) }, formData.getHeaders()),
+            maxContentLength: fileSize,
+            maxBodyLength: fileSize,
+        };
+        logger_1.logger.info('Upload file is in progress.');
+        const response = yield axios_1.default.post(uploadFileUrl, formData, headers);
+        logger_1.logger.debug('Exiting the uploadFileToServer function.');
+        return response;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception in the uploadFileToServer %s', error);
+        logger_1.logger.debug('Error code in the uploadFileToServer %s', error.code);
+        if (!error.response) {
+            if (error.code === 'ERR_FR_MAX_BODY_LENGTH_EXCEEDED') {
+                throw new Error(utils_1.errorMessage('ERROR_FILE_UPLOAD_SIZE_EXCEEDED', { 0: fileSize }, true));
+            }
+            else if (error.code === 'ENOTFOUND') {
+                throw new Error(utils_1.errorMessage('ERROR_HOSTNAME', {}, true));
+            }
+            else if (error.code === 'ECONNREFUSED') {
+                throw new Error(utils_1.errorMessage('ERROR_INVALID_PORT', {}, true));
+            }
+            else {
+                throw new Error(utils_1.errorMessage('ERROR_UNKNOWN_HOST', {}, true));
+            }
+        }
+        else if (error.response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+            throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        else if (error.response.status === constants_1.HttpStatus.SERVICE_UNAVAILABLE) {
+            throw new Error(utils_1.errorMessage('ERROR_DX_SERVICE_UNAVAILABLE', {}, true));
+        }
+        return error.response;
+    }
+});
+const deleteFileFromServer = (deleteFileURL, filePath, serverUsername, serverPassword) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the deleteFileFromServer function.');
+    logger_1.logger.debug('Delete File URL %s ', deleteFileURL);
+    logger_1.logger.debug('Delete File path %s ', filePath);
+    const headers = {
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: utils_1.baseEncode(serverUsername, serverPassword),
+        },
+    };
+    let deleteFilePath;
+    if (filePath) {
+        if (filePath.includes('/dxconnect/tmp')) {
+            deleteFilePath = filePath.substring(filePath.indexOf('/tmp') + 1, filePath.lastIndexOf('/'));
+        }
+        else {
+            deleteFilePath = filePath.substring(filePath.indexOf('\\tmp') + 1, filePath.lastIndexOf('\\'));
+        }
+        logger_1.logger.debug('Delete File path is not empty and folder is going to delete is ', deleteFilePath);
+    }
+    else {
+        logger_1.logger.debug('Delete File path is empty');
+        throw new Error(utils_1.errorMessage('ERROR_FILE_NOT_FOUND', {}, true));
+    }
+    const data = {
+        path: deleteFilePath,
+    };
+    try {
+        const response = yield axios_1.default.post(deleteFileURL, data, headers);
+        logger_1.logger.debug('Exiting the deleteFileFromServer function');
+        return response;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception in the deleteFileFromServer %s', error.response);
+        if (error.response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+            throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        return error.response;
+    }
+});
+const executeXmlAccess = (protocol, inputXmlfile, hostname, port, contextRoot, serverUsername, serverPassword, tagReplacer) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the executeXmlAccess function.');
+    logger_1.logger.debug('Input xml file %s ', inputXmlfile);
+    logger_1.logger.debug('Hostname of xmlaccess execution %s ', hostname);
+    logger_1.logger.debug('Port of xmlaccess execution %s ', port);
+    let inputData = '';
+    try {
+        inputData = yield filesServices_1.fileServices.readFileContent(inputXmlfile);
+        if (!inputData) {
+            throw new Error(utils_1.errorMessage('ERROR_READ_XML_FILE', { 0: 'File Content is empty' }, true));
+        }
+        if (tagReplacer === constants_1.CONSTANT_VALUES.actionExport) {
+            const changeAction = /(<web-app [\S\s]*?action=")[^"]+("[\S\s]*?>)/gmi;
+            const changeType = /(<request[\S\s]*?type=")[^"]+("[\S\s]*?>)/gmi;
+            inputData = inputData.replace(changeType, '$1export$2').replace(changeAction, '$1export$2');
+        }
+        else if (tagReplacer) {
+            logger_1.logger.debug('War file path is not empty : %s ', tagReplacer);
+            const url = `${constants_1.CONSTANT_VALUES.xmlreplaceTagValue}${tagReplacer}`;
+            inputData = inputData.replace(/(<url>.*<\/url>)/g, `<url>${url}</url>`);
+        }
+        logger_1.logger.debug('Input data value is  %s', inputData);
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception in reading the file');
+        throw new Error(error.message);
+    }
+    try {
+        if (contextRoot.startsWith('/')) {
+            contextRoot = contextRoot.substring(1);
+        }
+        const url = `${protocol}://${hostname}:${port}/${contextRoot}`;
+        logger_1.logger.debug('Url of the xml access %s ', url);
+        const headers = {
+            headers: {
+                'Content-Type': constants_1.CONTENT_TYPE.textXml,
+                Accept: constants_1.ACCEPT_TYPE.textOrXml,
+                'User-Agent': constants_1.CONSTANT_VALUES.userAgent,
+                Connection: constants_1.CONSTANT_VALUES.connection,
+                Authorization: utils_1.baseEncode(serverUsername, serverPassword),
+            },
+            maxContentLength: constants_1.REQUEST_MAXFILE_SIZE,
+            maxBodyLength: constants_1.REQUEST_MAXFILE_SIZE,
+        };
+        logger_1.logger.debug('Header : %s ', JSON.stringify(headers));
+        logger_1.logger.debug('XML Access execution started');
+        const resp = yield axios_1.default.post(url, inputData, headers);
+        logger_1.logger.debug('Exiting the executeXmlAccess function.');
+        return resp;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception in execute XmlAccess %s', JSON.stringify(error));
+        if ((error.code && error.code === constants_1.ERROR_MAX_BODY_LENGTH)
+            || (error.code && error.message && error.code === constants_1.ERROR_BAD_REQUEST && error.message === 'Request body larger than maxBodyLength limit')) {
+            throw new Error(utils_1.errorMessage('ERROR_FILE_UPLOAD_SIZE_EXCEEDED', { 0: constants_1.MAX_CONTENT_LENGTH }, true));
+        }
+        if (!error.response) {
+            throw new Error(utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true));
+        }
+        if (error.response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+            throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        if (error.response.status === constants_1.HttpStatus.FORBIDDEN) {
+            throw new Error(error.response.status);
+        }
+        if (error.response.status === constants_1.HttpStatus.INTERNAL_SERVER_ERROR) {
+            throw new Error(error.response.status);
+        }
+        return error.response;
+    }
+});
+const manageApplication = (applicationURL, appFilePath, dxSoapPort, dxUsername, dxPassword, dxConnectUserName, dxConnectPassword, appName, dxProfileName, dxProfilePath, requestId) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the deployApplication function.');
+    logger_1.logger.debug('Deploy Application URL %s ', applicationURL);
+    logger_1.logger.debug('Application File path %s ', appFilePath);
+    logger_1.logger.debug('DX Soap Port %s ', dxSoapPort);
+    logger_1.logger.debug('DX Profile Name %s ', dxProfileName);
+    logger_1.logger.debug('DX Profile Path %s ', dxProfilePath);
+    logger_1.logger.debug('Request Id %s ', requestId);
+    let response;
+    let counter = 1;
+    const jsonData = {
+        soapPort: dxSoapPort,
+        applicationFilePath: appFilePath,
+        applicationName: appName,
+    };
+    if (!requestId && !appFilePath && !applicationURL.includes(constants_1.URL_PARAMS.undeployApplication) && !applicationURL.includes(constants_1.URL_PARAMS.exportApplication)) {
+        logger_1.logger.debug('Application file path is invalid');
+        logger_1.logger.info(utils_1.errorMessage('ERROR_APPLICATION_PATH_INVALID'));
+        throw new Error(utils_1.errorMessage('ERROR_APPLICATION_PATH_INVALID'));
+    }
+    if (dxProfileName) {
+        jsonData.DXCoreProfileName = dxProfileName;
+    }
+    else if (dxProfilePath) {
+        jsonData.DXCoreProfilePath = dxProfilePath;
+    }
+    if (requestId) {
+        applicationURL = `${applicationURL}&uuid=${requestId}`;
+    }
+    try {
+        const axiosConfig = {
+            method: 'POST',
+            url: applicationURL,
+            data: jsonData,
+            headers: {
+                'Content-Type': constants_1.CONTENT_TYPE.applicationJson,
+                Authorization: utils_1.baseEncode(dxConnectUserName, dxConnectPassword),
+                DXAuth: utils_1.baseEncode(dxUsername, dxPassword),
+            },
+        };
+        logger_1.logger.debug('Manage Application request: %s', JSON.stringify(axiosConfig));
+        response = yield requestService_1.requestService.axiosService(axiosConfig);
+        if (!requestId) {
+            while (response && response.status === constants_1.HttpStatus.ACCEPTED) {
+                if (counter >= 5) {
+                    logger_1.logger.info(utils_1.errorMessage('RESPONSE_NOT_READY', {}, true));
+                    break;
+                }
+                yield new Promise((resolve) => {
+                    setTimeout(resolve, 60000);
+                });
+                logger_1.logger.debug('Try again with UUID - %s', response.data.uuid);
+                axiosConfig.url = `${applicationURL}&uuid=${response.data.uuid}`;
+                response = yield requestService_1.requestService.axiosService(axiosConfig);
+                counter += 1;
+            }
+        }
+        if (response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+            logger_1.logger.info(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception in the manageApplication %o', error);
+        logger_1.logger.error(error.message);
+    }
+    logger_1.logger.debug('Exiting the manageApplication function');
+    return response;
+});
+const login = (dxUsername, dxPassword, baseDxURL) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('login to DX with base URL: %s', baseDxURL);
+    const axiosRequestConfig = {
+        method: constants_1.GET,
+        url: `${baseDxURL}${constants_1.DX_LOGIN_PATH}`,
+        headers: {
+            'Content-Type': constants_1.CONTENT_TYPE.applicationJson,
+            Authorization: utils_1.baseEncode(dxUsername, dxPassword),
+        },
+    };
+    logger_1.logger.debug('Request configuration for login to DX - %s', JSON.stringify(axiosRequestConfig));
+    const response = yield requestService_1.requestService.axiosService(axiosRequestConfig);
+    if (!response) {
+        logger_1.logger.debug('Please ensure that the values for dxProtocol, hostname and dxPort are valid.');
+        throw new Error(utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true));
+    }
+    if (response.status === constants_1.HttpStatus.SUCCESS) {
+        return response.headers['set-cookie'][0];
+    }
+    if (response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+        logger_1.logger.debug('Login failed due to authorisation failure.');
+        throw new Error(utils_1.errorMessage('ERROR_LOGIN_AUTHORISATION', {}, true));
+    }
+    if (response.status === constants_1.HttpStatus.NOT_FOUND) {
+        logger_1.logger.debug('Please ensure that the value for contentHandlerPath is valid.');
+        throw new Error(utils_1.errorMessage('ERROR_INVALID_CONTENTHANDLER', { 0: baseDxURL }, true));
+    }
+    logger_1.logger.debug('Response from DX server: %o', response);
+    throw response.statusText;
+});
+const searchWebContents = (baseDxURL, cookie, query) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the searchWebContents function.');
+    try {
+        const axiosConfig = {
+            method: constants_1.GET,
+            url: `${baseDxURL}${constants_1.DX_GET_QUERY_URI_PATH}?${query}`,
+            headers: { Cookie: cookie },
+        };
+        logger_1.logger.debug('Request configuration for query  - %s is %s', query, JSON.stringify(axiosConfig));
+        return requestService_1.requestService.axiosService(axiosConfig);
+    }
+    catch (error) {
+        logger_1.logger.error('Exception while search web contents data: %o', error);
+        throw error;
+    }
+});
+const getWCMLibraryIdFromName = (baseDxURL, cookie, wcmLibraryName) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the getWCMLibraryIdFromName function.');
+    try {
+        const axiosConfig = {
+            method: constants_1.GET,
+            url: `${baseDxURL}${constants_1.DX_GET_QUERY_URI_PATH}?type=Library&title=${wcmLibraryName}`,
+            headers: { Cookie: cookie },
+        };
+        logger_1.logger.debug('Request configuration for querying the contents for the library id or name - %s is %s', wcmLibraryName, JSON.stringify(axiosConfig));
+        const response = yield requestService_1.requestService.axiosService(axiosConfig);
+        if (!response) {
+            logger_1.logger.debug('Please check dxProtocol/hostname/Port are valid or not.');
+            return '';
+        }
+        if (response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+            throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        if (response && response.status === constants_1.HttpStatus.SUCCESS) {
+            if (response.data && response.data.feed && response.data.feed.entry && response.data.feed.entry.length > 0) {
+                const libraryIdsArray = yield Promise.all(response.data.feed.entry.map((item) => __awaiter(void 0, void 0, void 0, function* () {
+                    if ('id' in item) {
+                        item.id = item.id.replace(/^wcmrest:/, '');
+                    }
+                    logger_1.logger.debug('Retrieved library ID for library name - %s, library id is - %s', wcmLibraryName, item.id);
+                    return item.id;
+                })));
+                return libraryIdsArray[0];
+            }
+            logger_1.logger.error(utils_1.errorMessage('ERROR_NO_ID_FOUND_FOR_NAME', { 0: wcmLibraryName }));
+            return '';
+        }
+        logger_1.logger.error(utils_1.errorMessage('ERROR_NO_ID_FOUND_FOR_NAME', { 0: wcmLibraryName }));
+        return '';
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception while getting ID from library name: %o', error);
+        throw error;
+    }
+});
+const getWCMProjectIdFromName = (baseDxURL, cookie, wcmProjectName) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the getWCMProjectIdFromName function.');
+    try {
+        const axiosConfig = {
+            method: constants_1.GET,
+            url: `${baseDxURL}${constants_1.DX_GET_QUERY_URI_PATH}?type=Project&name=${wcmProjectName}`,
+            headers: { Cookie: cookie },
+        };
+        logger_1.logger.debug('Request configuration for querying the contents for the project name - %s is %s', wcmProjectName, JSON.stringify(axiosConfig));
+        const response = yield requestService_1.requestService.axiosService(axiosConfig);
+        if (!response) {
+            logger_1.logger.debug('Please check dxProtocol/hostname/Port are valid or not.');
+            throw new Error(utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true));
+        }
+        if (response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+            throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        if (response && response.status === constants_1.HttpStatus.SUCCESS) {
+            if (response.data && response.data.feed && response.data.feed.entry && response.data.feed.entry.length > 0) {
+                const projectIdsArray = yield Promise.all(response.data.feed.entry.map((item) => __awaiter(void 0, void 0, void 0, function* () {
+                    if ('id' in item) {
+                        item.id = item.id.replace(/^wcmrest:/, '');
+                    }
+                    logger_1.logger.debug('Retrieved project ID for project name - %s, project id is - %s', wcmProjectName, item.id);
+                    return item.id;
+                })));
+                return projectIdsArray[0];
+            }
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_NO_PROJECT_ID_FOUND_FOR_NAME', { 0: wcmProjectName }));
+            throw new Error(utils_1.errorMessage('ERROR_NO_PROJECT_ID_FOUND_FOR_NAME', { 0: wcmProjectName }));
+        }
+        logger_1.logger.debug(utils_1.errorMessage('ERROR_NO_PROJECT_ID_FOUND_FOR_NAME', { 0: wcmProjectName }));
+        throw new Error(utils_1.errorMessage('ERROR_NO_PROJECT_ID_FOUND_FOR_NAME', { 0: wcmProjectName }));
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception while getting ID from project name: %o', error);
+        throw error;
+    }
+});
+const queryBuilder = (page, wcmLibraryId, wcmProjectId, lastModifiedAfter) => __awaiter(void 0, void 0, void 0, function* () {
+    let query = '';
+    if (wcmLibraryId) {
+        query = `type=Content&libraryId=${wcmLibraryId}&pageSize=${constants_1.SEARCH_PAGESIZE}&page=${page}`;
+    }
+    else {
+        query += `type=Content&projectId=${wcmProjectId}&pageSize=${constants_1.SEARCH_PAGESIZE}&page=${page}`;
+    }
+    if (lastModifiedAfter) {
+        const dateFormat = 'yyyy-MM-dd\'T\'HH:mm';
+        query += `&lastmodifiedafter=${urlencode_1.default(lastModifiedAfter)}&dateformat=${urlencode_1.default(dateFormat)}`;
+    }
+    return query;
+});
+const getWebContentIds = (baseDxURL, cookie, page, wcmLibraryId, wcmProjectName, wcmProjectId, lastModifiedAfter) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the getWebContentIds function.');
+    let contentsIds = [];
+    logger_1.logger.debug('Searching web contents with page: %s %d', wcmLibraryId || wcmProjectName, page);
+    try {
+        const queryType = wcmLibraryId ? `library id - ${wcmLibraryId}` : `project name - ${wcmProjectName}`;
+        for (page;; page += 1) {
+            const response = yield searchWebContents(baseDxURL, cookie, yield queryBuilder(page, wcmLibraryId, wcmProjectId, lastModifiedAfter));
+            if (!response) {
+                logger_1.logger.debug('Please check dxProtocol/hostname/Port are valid or not.');
+                return [];
+            }
+            if (response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+                logger_1.logger.debug(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+                throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+            }
+            if (response.data && response.data.feed && response.data.feed.entry && response.data.feed.entry.length > 0) {
+                const contentsIdsArray = yield Promise.all(response.data.feed.entry.map((item) => __awaiter(void 0, void 0, void 0, function* () {
+                    const contentItem = {
+                        contentId: null,
+                        lang: null,
+                    };
+                    if ('id' in item) {
+                        contentItem.contentId = item.id.replace(/^wcmrest:/, '');
+                        if (item.summary && item.summary.lang) {
+                            contentItem.lang = item.summary.lang;
+                        }
+                    }
+                    return contentItem;
+                })));
+                contentsIds = [...contentsIds, ...contentsIdsArray];
+            }
+            else if (response.data && response.data.feed && (!response.data.feed.entry || (response.data.feed.entry && !response.data.feed.entry.length))) {
+                logger_1.logger.debug('No contents found for : %s- ', queryType);
+                logger_1.logger.error(utils_1.errorMessage('ERROR_NO_CONTENTS_FOR_LIBRARY_OR_PROJECT', { 0: queryType }));
+                break;
+            }
+            else {
+                logger_1.logger.debug('Exception while searching web contents data: %d', response.status);
+                logger_1.logger.error(utils_1.errorMessage('ERROR_SEARCHING_CONTENTS_DATA', { 0: queryType }));
+                break;
+            }
+            if (response.data.feed && (response.data.feed.total <= constants_1.SEARCH_PAGESIZE || ((constants_1.SEARCH_PAGESIZE * page) > response.data.feed.total))) {
+                break;
+            }
+        }
+        logger_1.logger.debug('Contents searched from given data, contents length - %d', contentsIds.length);
+        return contentsIds;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception while searching web contents data: %o', error);
+        throw error;
+    }
+});
+const getMultilingualTranslationsData = (baseDxURL, cookie, wcmContentIds, wcmProjectId) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the getMultilingualTranslationsData function.');
+    try {
+        logger_1.logger.debug('Retrieving translated web contents for the specified web content ids.');
+        const contentsResponse = [];
+        for (let index = 0; index < wcmContentIds.length; index += 1) {
+            const axiosConfig = {
+                method: constants_1.GET,
+                url: `${baseDxURL}${constants_1.DX_GET_TRANSLATIONS_URI_PATH}/${wcmContentIds[index].contentId}?allAvailableLang=true&props=true`,
+                headers: { Cookie: cookie },
+            };
+            logger_1.logger.debug('Request configuration for retrieve the translated web contents for the content id - %s is %s', wcmContentIds[index].contentId, JSON.stringify(axiosConfig));
+            const response = yield requestService_1.requestService.axiosService(axiosConfig);
+            if (!response) {
+                logger_1.logger.debug('Please check dxProtocol/hostname/Port are valid or not.');
+                return [];
+            }
+            if (response && response.status === constants_1.HttpStatus.SUCCESS) {
+                const responseData = response.data.entry.content.data;
+                if (wcmProjectId) {
+                    if (wcmContentIds[index].lang && (wcmContentIds[index].lang !== responseData.source_language)) {
+                        logger_1.logger.info(utils_1.message('MLS_EXPORT_RETRIEVED_TRANSLATION', { 0: wcmContentIds[index].contentId }));
+                    }
+                    else {
+                        logger_1.logger.error(utils_1.errorMessage('ERROR_SOURCE_LANGUAGE', { 0: wcmContentIds[index].contentId, 1: responseData.translated_items[0].source_content.locale }));
+                    }
+                    if (responseData.translated_items && responseData.translated_items.length) {
+                        for (let translationIndex = 0; translationIndex < responseData.translated_items.length; translationIndex += 1) {
+                            if (responseData.translated_items[translationIndex].translated_content && responseData.translated_items[translationIndex].translated_content.length) {
+                                responseData.translated_items[translationIndex].translated_content = responseData.translated_items[translationIndex].translated_content.filter((item) => {
+                                    return item.locale === wcmContentIds[index].lang;
+                                });
+                            }
+                        }
+                    }
+                }
+                else {
+                    logger_1.logger.info(utils_1.message('MLS_EXPORT_RETRIEVED_TRANSLATION', { 0: wcmContentIds[index].contentId }));
+                }
+                if (responseData.translated_items && responseData.translated_items[0].translated_content && responseData.translated_items[0].translated_content.length) {
+                    contentsResponse.push(responseData);
+                }
+                else {
+                    logger_1.logger.error(utils_1.errorMessage('ERROR_NO_TRANSLATED_DATA_FOUND', { 0: wcmContentIds[index].contentId }));
+                }
+            }
+            else {
+                logger_1.logger.error(utils_1.errorMessage('ERROR_NO_TRANSLATED_DATA_FOUND', { 0: wcmContentIds[index].contentId }));
+                return [];
+            }
+        }
+        logger_1.logger.debug('Translated contents found, contents length - %d', contentsResponse.length);
+        return contentsResponse;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception while retrieving translated contents data: %o', error);
+        throw error;
+    }
+});
+const validateContentImport = (baseDxURL, cookie, wcmContentId, lastModifiedDateOfSource, lastModifiedDateOfTarget, targetLanguagesUUIDs) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        if (lastModifiedDateOfSource && lastModifiedDateOfTarget
+            && !Number.isNaN(new Date(lastModifiedDateOfSource).getTime())
+            && !Number.isNaN(new Date(lastModifiedDateOfTarget).getTime())) {
+            logger_1.logger.debug('Retrieving translated web contents for the specified web content ids.');
+            const axiosConfig = {
+                method: constants_1.GET,
+                url: `${baseDxURL}${constants_1.DX_GET_TRANSLATIONS_URI_PATH}/${wcmContentId}?allAvailableLang=true&props=true`,
+                headers: { Cookie: cookie },
+            };
+            logger_1.logger.debug('Requested configuration for retrieve the translated web contents for the content id - %s is %s', wcmContentId, JSON.stringify(axiosConfig));
+            const response = yield requestService_1.requestService.axiosService(axiosConfig);
+            if (response && response.status === constants_1.HttpStatus.SUCCESS) {
+                const responseData = response.data.entry.content.data;
+                const targetModifiedDates = [];
+                if (responseData.translated_items && responseData.translated_items.length > 0) {
+                    const translatedItems = responseData.translated_items[0];
+                    if (translatedItems.source_content.updated) {
+                        const sourceModifiedDate = new Date(translatedItems.source_content.updated).toUTCString();
+                        const sourceValidation = new Date(lastModifiedDateOfSource).getTime() >= new Date(sourceModifiedDate).getTime();
+                        if (translatedItems.translated_content && translatedItems.translated_content.length > 0) {
+                            translatedItems.translated_content.forEach((translatedContent) => {
+                                if (targetLanguagesUUIDs.includes(translatedContent.uuid) && translatedContent.updated) {
+                                    targetModifiedDates.push(translatedContent.updated);
+                                }
+                            });
+                            if (targetModifiedDates.length > 0) {
+                                const targetValidation = targetModifiedDates.every((date) => {
+                                    const targetModifiedDate = new Date(date).toUTCString();
+                                    return new Date(lastModifiedDateOfTarget).getTime() >= new Date(targetModifiedDate).getTime();
+                                });
+                                logger_1.logger.debug('Content Id - %s, source validation - %s, target validation - %s', wcmContentId, sourceValidation, targetValidation);
+                                return sourceValidation && targetValidation;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception while retrieving translated contents data: %o', error);
+        throw error;
+    }
+});
+const importMultilingualTranslationsData = (sourceContentIds, fileData, token, baseDXUrl, projectName, forceImport) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        let validationResult = true;
+        logger_1.logger.debug('Importing translated web contents for the specified web content ids.');
+        if (projectName) {
+            baseDXUrl += `/$project/${projectName}`;
+            logger_1.logger.debug('baseDXUrl appended with project name - %s', baseDXUrl);
+        }
+        for (let sourceContentIndex = 0; sourceContentIndex < sourceContentIds.length; sourceContentIndex += 1) {
+            const filteredElementsData = lodash_1.filter(fileData, { sourceUUID: sourceContentIds[sourceContentIndex], type: constants_1.CONTENT_ELEMENT_TYPE, wcmType: constants_1.WCM_TYPE });
+            const filteredInfoData = lodash_1.filter(fileData, { sourceUUID: sourceContentIds[sourceContentIndex], type: constants_1.CONTENT_INFORMATION_TYPE, wcmType: constants_1.WCM_TYPE });
+            const filteredData = [...filteredElementsData, ...filteredInfoData];
+            const lastModifiedDateOfSource = filteredData[0].lastModifiedOfSource;
+            const lastModifiedDateOfTarget = lodash_1.reduce(filteredData, (lastModifiedDate, data) => {
+                const maxDate = Math.max(new Date(lastModifiedDate).getTime(), new Date(data.lastModifiedOfTarget).getTime());
+                return new Date(maxDate).toUTCString();
+            }, filteredData[0].lastModifiedOfTarget);
+            const targetLanguagesObj = {};
+            filteredData.forEach((row) => {
+                if (!targetLanguagesObj[row.targetLanguage]) {
+                    targetLanguagesObj[row.targetLanguage] = 1;
+                }
+            });
+            const targetLanguages = Object.keys(targetLanguagesObj);
+            const targetLanguagesUUIDObj = {};
+            filteredData.forEach((row) => {
+                if (!targetLanguagesUUIDObj[row.targetUUID]) {
+                    targetLanguagesUUIDObj[row.targetUUID] = 1;
+                }
+            });
+            const targetLanguagesUUIDs = Object.keys(targetLanguagesUUIDObj);
+            if (!forceImport) {
+                validationResult = yield validateContentImport(baseDXUrl, token, sourceContentIds[sourceContentIndex], lastModifiedDateOfSource, lastModifiedDateOfTarget, targetLanguagesUUIDs);
+            }
+            logger_1.logger.debug('Import validation result for content Id - %s is - %s', sourceContentIds[sourceContentIndex], validationResult);
+            if (validationResult) {
+                const targetElementsData = [];
+                targetLanguages.forEach((targetLanguage) => {
+                    const importElementsData = [];
+                    const filteredTargetInfoData = lodash_1.filter(filteredInfoData, { targetLanguage });
+                    const titleContent = filteredTargetInfoData.find((title) => { return title.field === constants_1.CONTENT_TITLE_TYPE; });
+                    const descriptionContent = filteredTargetInfoData.find((description) => { return description.field === constants_1.CONTENT_DESCRIPTION_TYPE; });
+                    const filteredTargetLanguageData = lodash_1.filter(filteredElementsData, { targetLanguage });
+                    filteredTargetLanguageData.forEach((data) => {
+                        importElementsData.push({
+                            name: data.field,
+                            type: data.componentType,
+                            data: {
+                                type: ((data.componentType === constants_1.WCMElementTypes.HTML_COMPONENT || data.componentType === constants_1.WCMElementTypes.RICH_TEXT_COMPONENT) ? constants_1.WCMDataType.HTML : constants_1.WCMDataType.TEXT),
+                                value: data.target,
+                            },
+                        });
+                    });
+                    targetElementsData.push(Object.assign(Object.assign(Object.assign({}, titleContent && {
+                        title: {
+                            lang: titleContent.targetLanguage,
+                            value: titleContent.target,
+                        },
+                    }), descriptionContent && {
+                        description: {
+                            lang: descriptionContent.targetLanguage,
+                            value: descriptionContent.target,
+                        },
+                    }), { elements: { element: importElementsData }, uuid: filteredTargetInfoData[0].targetUUID || filteredTargetLanguageData[0].targetUUID, locale: targetLanguage }));
+                });
+                const importRequestData = {
+                    entry: {
+                        content: {
+                            data: {
+                                translated_items: [{ translated_content: targetElementsData }],
+                            },
+                        },
+                    },
+                };
+                const axiosRequestConfig = {
+                    method: constants_1.PUT,
+                    baseURL: baseDXUrl,
+                    url: `${constants_1.DX_GET_TRANSLATIONS_URI_PATH}/${sourceContentIds[sourceContentIndex]}?allAvailableLang=true`,
+                    data: importRequestData,
+                    withCredentials: true,
+                    headers: {
+                        Cookie: token,
+                        accept: constants_1.CONTENT_TYPE.applicationJson,
+                        'content-type': constants_1.CONTENT_TYPE.applicationJson,
+                    },
+                };
+                logger_1.logger.debug('Request configuration for importing translated data for the source content id - %s is %o', sourceContentIds[sourceContentIndex], axiosRequestConfig);
+                const response = yield requestService_1.requestService.axiosService(axiosRequestConfig);
+                if (response && response.status === constants_1.HttpStatus.SUCCESS) {
+                    logger_1.logger.info(utils_1.message('MLS_IMPORT_TRANSLATION_DATA_SUCCESS', { 0: sourceContentIds[sourceContentIndex] }));
+                }
+                else {
+                    const result = response ? JSON.stringify(response.data) : utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true);
+                    logger_1.logger.error(utils_1.message('MLS_IMPORT_TRANSLATION_DATA_ERROR', { 0: sourceContentIds[sourceContentIndex], 1: result }));
+                }
+            }
+            else {
+                logger_1.logger.error(utils_1.message('MLS_IMPORT_VALIDATION_FAILED', { 0: sourceContentIds[sourceContentIndex] }));
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception while importing translated contents data: %o', error);
+        throw error;
+    }
+});
+const downloadApplication = (downloadUrl, dxUsername, dxPassword, dxConnectUsername, dxConnectPassword) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Download Url is : %s', downloadUrl);
+    const axiosConfig = {
+        method: 'GET',
+        url: downloadUrl,
+        responseType: constants_1.RESPONSE_TYPE,
+        headers: {
+            Authorization: utils_1.baseEncode(dxConnectUsername, dxConnectPassword),
+            DXAuth: utils_1.baseEncode(dxUsername, dxPassword),
+        },
+    };
+    logger_1.logger.debug('Axios request for download application is : %o', axiosConfig);
+    const response = yield requestService_1.requestService.axiosService(axiosConfig);
+    if (!response) {
+        logger_1.logger.debug(utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true));
+        throw new Error(utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true));
+    }
+    switch (response.status) {
+        case constants_1.HttpStatus.UNAUTHORIZED: {
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_THEME_AUTHORISATION'));
+            throw new Error(utils_1.errorMessage('ERROR_THEME_AUTHORISATION'));
+        }
+        case constants_1.HttpStatus.BAD_REQUEST: {
+            logger_1.logger.debug('Please provide a valid url');
+            return false;
+        }
+        case constants_1.HttpStatus.NOT_FOUND: {
+            try {
+                logger_1.logger.debug('Application not found.');
+                let result = yield utils_1.streamToString(response.data);
+                result = JSON.parse(result);
+                throw new Error(result.message);
+            }
+            catch (error) {
+                throw new Error(error);
+            }
+        }
+        case constants_1.HttpStatus.SUCCESS: {
+            logger_1.logger.debug('Success in execution of download zip axios call.');
+            return response.data;
+        }
+        case constants_1.HttpStatus.INTERNAL_SERVER_ERROR: {
+            logger_1.logger.debug('Execution of undeploy theme failed due to internal server error');
+            return false;
+        }
+        default:
+            logger_1.logger.debug('Execution of undeploy theme failed');
+            return false;
+    }
+});
+const listDAMSchema = (damURL, cookie) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering to the listDAMSchema function');
+    const axiosConfig = {
+        method: constants_1.GET,
+        url: `${damURL}/schemas`,
+        headers: { Cookie: cookie },
+    };
+    logger_1.logger.debug('DAM axiosConfig - %o', axiosConfig);
+    const response = yield requestService_1.requestService.axiosService(axiosConfig);
+    if (!response) {
+        logger_1.logger.debug('Response is undefined');
+        throw new Error(utils_1.errorMessage('ERROR_DAMAPI_RESPONSE_UNDEFINED'));
+    }
+    logger_1.logger.debug('listDAMSchema Response  : %o', response);
+    switch (response.status) {
+        case constants_1.HttpStatus.UNAUTHORIZED: {
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+            throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        case constants_1.HttpStatus.SUCCESS: {
+            logger_1.logger.debug('Execution of schema : success');
+            return response;
+        }
+        case constants_1.HttpStatus.FORBIDDEN: {
+            logger_1.logger.debug('Access denied for selected schema');
+            throw new Error(utils_1.errorMessage('ERROR_ACCESS_DENIED'));
+        }
+        case constants_1.HttpStatus.NOT_FOUND: {
+            logger_1.logger.debug('Please enter a valid damAPIVersion');
+            throw new Error(utils_1.errorMessage('ERROR_DAMAPI_VERSION'));
+        }
+        case constants_1.HttpStatus.INTERNAL_SERVER_ERROR: {
+            logger_1.logger.debug('Failed to delete schema');
+            throw new Error(utils_1.errorMessage('ERROR_FAILED_SCHEMA_DELETE'));
+        }
+        default:
+            logger_1.logger.debug('Execution of schema get failed');
+            return false;
+    }
+});
+const deleteDAMSchema = (damURL, cookie, schemaVersion) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering to the deleteDAMSchema function');
+    const axiosConfig = {
+        method: constants_1.DELETE,
+        url: `${damURL}/schemas/${schemaVersion}`,
+        headers: { Cookie: cookie },
+    };
+    logger_1.logger.debug('DAM axiosConfig - %o', axiosConfig);
+    const response = yield requestService_1.requestService.axiosService(axiosConfig);
+    if (!response) {
+        logger_1.logger.debug('Response is undefined');
+        throw new Error(utils_1.errorMessage('ERROR_DAMAPI_RESPONSE_UNDEFINED'));
+    }
+    logger_1.logger.debug('deleteDAMSchema Response  : %o', response);
+    switch (response.status) {
+        case constants_1.HttpStatus.UNAUTHORIZED: {
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+            throw new Error(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        case constants_1.HttpStatus.NO_CONTENT: {
+            logger_1.logger.info(utils_1.message('DAM_SCHEMA_DELETE_SUCCESS'));
+            return true;
+        }
+        case constants_1.HttpStatus.NOT_FOUND: {
+            if (!response.data.error) {
+                logger_1.logger.debug('Please enter a valid damAPIVersion');
+                throw new Error(utils_1.errorMessage('ERROR_DAMAPI_VERSION'));
+            }
+            else {
+                logger_1.logger.debug('Please provide a valid schema version');
+                throw new Error(utils_1.errorMessage('ERROR_SCHEMA_NOT_FOUND', { 0: schemaVersion }));
+            }
+        }
+        case constants_1.HttpStatus.FORBIDDEN: {
+            logger_1.logger.debug('Access denied for selected schema');
+            throw new Error(utils_1.errorMessage('ERROR_ACCESS_DENIED'));
+        }
+        case constants_1.HttpStatus.CONFLICT: {
+            logger_1.logger.debug('You are not allowed to delete an active schema');
+            throw new Error(utils_1.errorMessage('ERROR_ACTIVE_SCHEMA_NOT_DELETE'));
+        }
+        case constants_1.HttpStatus.INTERNAL_SERVER_ERROR: {
+            logger_1.logger.debug('Failed to delete schema');
+            throw new Error(utils_1.errorMessage('ERROR_FAILED_SCHEMA_DELETE'));
+        }
+        default:
+            logger_1.logger.debug('Exception while deleting DAM Schema : failed');
+            return false;
+    }
+});
+const loginWithRingAPI = (dxUsername, dxPassword, ringAPIURL) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('login to DX with DXCore API URL: %s', ringAPIURL);
+    const axiosRequestConfig = {
+        method: constants_1.POST,
+        url: `${ringAPIURL}/auth/login`,
+        data: {
+            username: dxUsername,
+            password: dxPassword,
+        },
+    };
+    const logAxiosRequestConfig = Object.assign(Object.assign({}, axiosRequestConfig), { data: Object.assign(Object.assign({}, axiosRequestConfig.data), { password: MaskData.maskPassword(dxPassword) }) });
+    logger_1.logger.debug('Request configuration for login to DX - %s', JSON.stringify(logAxiosRequestConfig));
+    const response = yield requestService_1.requestService.axiosService(axiosRequestConfig);
+    if (!response) {
+        logger_1.logger.debug('Please ensure that the values for dxProtocol, hostname and dxPort are valid.');
+        throw new Error(utils_1.errorMessage('ERROR_RINGAPI_RESPONSE_UNDEFINED'));
+    }
+    switch (response.status) {
+        case constants_1.HttpStatus.SUCCESS: {
+            logger_1.logger.debug('loginWithRingAPI response : %s', response.data.message);
+            return response.headers['set-cookie'][0];
+        }
+        case constants_1.HttpStatus.UNAUTHORIZED: {
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_LOGIN_AUTHORISATION', {}, true));
+            throw new Error(utils_1.errorMessage('ERROR_LOGIN_AUTHORISATION', {}, true));
+        }
+        case constants_1.HttpStatus.NOT_FOUND: {
+            logger_1.logger.debug(utils_1.errorMessage('ERROR_RINGAPI_VERSION'));
+            throw new Error(utils_1.errorMessage('ERROR_RINGAPI_VERSION'));
+        }
+        default:
+            logger_1.logger.debug('Delete dam schema error response %s', JSON.stringify(response.data));
+            throw new Error(utils_1.errorMessage('ERROR_DELETE_SCHEMA_RESPONSE', { 0: response.statusText }));
+    }
+});
+const startApplication = (startApplicationURL, dxSoapPort, credObj, appName, dxProfileName, dxProfilePath, startAppDetails) => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.logger.debug('Entering the start deployApplication function.');
+    logger_1.logger.debug('DX Soap Port %s ', dxSoapPort);
+    logger_1.logger.debug('DX Profile Name %s ', dxProfileName);
+    logger_1.logger.debug('DX Profile Path %s ', dxProfilePath);
+    logger_1.logger.debug('Application Name %s ', appName);
+    logger_1.logger.debug('Start Application Details %s ', startAppDetails);
+    let startApprResp = false;
+    const jsonData = {
+        soapPort: dxSoapPort,
+        applicationName: appName,
+        startAppDetails,
+    };
+    if (dxProfileName) {
+        jsonData.DXCoreProfileName = dxProfileName;
+    }
+    else if (dxProfilePath) {
+        jsonData.DXCoreProfilePath = dxProfilePath;
+    }
+    try {
+        const axiosConfig = {
+            method: 'POST',
+            url: startApplicationURL,
+            data: jsonData,
+            headers: {
+                'Content-Type': constants_1.CONTENT_TYPE.applicationJson,
+                Authorization: utils_1.baseEncode(credObj.dxConnectUsername, credObj.dxConnectPassword),
+                DXAuth: utils_1.baseEncode(credObj.dxUsername, credObj.dxPassword),
+            },
+        };
+        logger_1.logger.debug('Start Manage Application request: %s', JSON.stringify(axiosConfig));
+        const response = yield requestService_1.requestService.axiosService(axiosConfig);
+        logger_1.logger.debug('Exiting the start manageApplication function');
+        if (!response) {
+            logger_1.logger.debug('Response is undefined');
+            throw new Error(utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true));
+        }
+        if (response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+            logger_1.logger.info(utils_1.errorMessage('ERROR_UNAUTHORIZED', {}, true));
+        }
+        else if (response.status === constants_1.HttpStatus.SUCCESS) {
+            logger_1.logger.info(response.data.message);
+            startApprResp = true;
+        }
+        return startApprResp;
+    }
+    catch (error) {
+        logger_1.logger.debug('Exception in the manageApplication %o', error.response.data);
+        return error.response;
+    }
+});
+const fetchDXCoreVersion = (credObj, baseDxURL) => __awaiter(void 0, void 0, void 0, function* () {
+    const dxVersionUrl = `${baseDxURL}${constants_1.URL_PARAMS.version}`;
+    logger_1.logger.debug('login to DX with base URL: %s', baseDxURL);
+    const axiosRequestConfig = {
+        method: constants_1.GET,
+        url: `${dxVersionUrl}`,
+        headers: {
+            'Content-Type': constants_1.CONTENT_TYPE.applicationJson,
+            Authorization: utils_1.baseEncode(credObj.dxConnectUsername, credObj.dxConnectPassword),
+        },
+    };
+    logger_1.logger.debug('Request configuration for login to DX - %s', JSON.stringify(axiosRequestConfig));
+    const response = yield requestService_1.requestService.axiosService(axiosRequestConfig);
+    if (!response) {
+        logger_1.logger.debug('Please ensure that the values for dxProtocol, hostname and dxPort are valid.');
+        throw new Error(utils_1.errorMessage('ERROR_RESPONSE_UNDEFINED', {}, true));
+    }
+    if (response.status === constants_1.HttpStatus.SUCCESS) {
+        logger_1.logger.debug('DX Core Version is %s', response.data.version);
+        return response.data.version;
+    }
+    if (response.status === constants_1.HttpStatus.UNAUTHORIZED) {
+        logger_1.logger.debug('Login failed due to authorisation failure.');
+        throw new Error(utils_1.errorMessage('ERROR_LOGIN_AUTHORISATION', {}, true));
+    }
+    logger_1.logger.debug('Response from DX server: %o', response);
+    throw response.statusText;
+});
+exports.apiServices = {
+    uploadFileToServer,
+    deleteFileFromServer,
+    executeXmlAccess,
+    manageApplication,
+    downloadApplication,
+    getWebContentIds,
+    getMultilingualTranslationsData,
+    importMultilingualTranslationsData,
+    getWCMLibraryIdFromName,
+    getWCMProjectIdFromName,
+    validateContentImport,
+    listDAMSchema,
+    deleteDAMSchema,
+    loginWithRingAPI,
+    login,
+    startApplication,
+    fetchDXCoreVersion,
+};
+//# sourceMappingURL=apiServices.js.map