@celonis/content-cli 1.11.0 → 1.12.0

package/commands/{configuration-management/batch-import-export.service.js → t2tc/t2tc-package.service.js}

@@ -13,65 +13,55 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "uuid", "form-data", "stream", "adm-zip", "./interfaces/batch-export-import.constants", "../../core/utils/file-service", "../../core/utils/logger", "../../core/utils/json", "../studio/api/package-api", "./api/batch-import-export-api", "./studio.service", "../../core/git-profile/git/git.service", "fs", "../../core/utils/file.constants"], factory);
+        define(["require", "exports", "uuid", "form-data", "stream", "adm-zip", "./batch-export-import.constants", "../../core/utils/file-service", "../../core/utils/logger", "../../core/utils/json", "../studio/api/package-api", "./api/t2tc-package-api", "../configuration-management/api/variable-api", "../configuration-management/connection-variable.helper", "./studio.service", "../../core/git-profile/git/git.service", "fs", "../../core/utils/file.constants"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.BatchImportExportService = void 0;
+    exports.T2tcPackageService = void 0;
     const uuid_1 = require("uuid");
     const FormData = require("form-data");
     const stream_1 = require("stream");
     const AdmZip = require("adm-zip");
-    const batch_export_import_constants_1 = require("./interfaces/batch-export-import.constants");
+    const batch_export_import_constants_1 = require("./batch-export-import.constants");
     const file_service_1 = require("../../core/utils/file-service");
     const logger_1 = require("../../core/utils/logger");
     const json_1 = require("../../core/utils/json");
     const package_api_1 = require("../studio/api/package-api");
-    const batch_import_export_api_1 = require("./api/batch-import-export-api");
+    const t2tc_package_api_1 = require("./api/t2tc-package-api");
+    const variable_api_1 = require("../configuration-management/api/variable-api");
+    const connection_variable_helper_1 = require("../configuration-management/connection-variable.helper");
     const studio_service_1 = require("./studio.service");
     const git_service_1 = require("../../core/git-profile/git/git.service");
     const fs = require("fs");
     const file_constants_1 = require("../../core/utils/file.constants");
-    class BatchImportExportService {
+    class T2tcPackageService {
         constructor(context) {
-            this.batchImportExportApi = new batch_import_export_api_1.BatchImportExportApi(context);
+            this.t2tcPackageApi = new t2tc_package_api_1.T2tcPackageApi(context);
+            this.variableApi = new variable_api_1.VariableApi(context);
             this.studioPackageApi = new package_api_1.PackageApi(context);
             this.studioService = new studio_service_1.StudioService(context);
             this.gitService = new git_service_1.GitService(context);
         }
         listActivePackages(flavors, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
-                const activePackages = yield this.batchImportExportApi.findAllActivePackages(flavors, false, includeBranches);
+                const activePackages = yield this.t2tcPackageApi.findAllActivePackages(flavors, false, includeBranches);
                 activePackages.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
             });
         }
-        listStagingPackages(flavors, includeBranches, jsonResponse) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const stagingPackages = yield this.batchImportExportApi.findAllStagingPackages(flavors, includeBranches);
-                if (jsonResponse) {
-                    this.exportListOfPackages(stagingPackages);
-                }
-                else {
-                    stagingPackages.forEach(pkg => {
-                        logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
-                    });
-                }
-            });
-        }
         findAndExportListOfPackages(flavors, packageKeys, keysByVersion, withDependencies, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
                 let packagesToExport;
                 if (keysByVersion.length) {
-                    packagesToExport = yield this.batchImportExportApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
+                    packagesToExport = yield this.t2tcPackageApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
                 }
                 else if (packageKeys.length) {
-                    packagesToExport = yield this.batchImportExportApi.findActivePackagesByKeys(packageKeys, withDependencies);
+                    packagesToExport = yield this.t2tcPackageApi.findActivePackagesByKeys(packageKeys, withDependencies);
                 }
                 else {
-                    packagesToExport = yield this.batchImportExportApi.findAllActivePackages(flavors, withDependencies, includeBranches);
+                    packagesToExport = yield this.t2tcPackageApi.findAllActivePackages(flavors, withDependencies, includeBranches);
                 }
                 packagesToExport = yield this.studioService.getExportPackagesWithStudioData(packagesToExport, withDependencies);
                 this.exportListOfPackages(packagesToExport);
@@ -79,7 +69,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         listPackagesByKeysWithVersion(keysByVersion, withDependencies) {
             return __awaiter(this, void 0, void 0, function* () {
-                const exportedPackages = yield this.batchImportExportApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
+                const exportedPackages = yield this.t2tcPackageApi.findPackagesByKeysAndVersion(keysByVersion, withDependencies);
                 exportedPackages.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
@@ -89,16 +79,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return __awaiter(this, void 0, void 0, function* () {
                 let exportedPackagesData;
                 if (packageKeys) {
-                    exportedPackagesData = yield this.batchImportExportApi.exportPackages(packageKeys, withDependencies);
+                    exportedPackagesData = yield this.t2tcPackageApi.exportPackages(packageKeys, withDependencies);
                 }
                 else {
-                    exportedPackagesData = yield this.batchImportExportApi.exportPackagesByVersions(packageKeysByVersion, withDependencies);
+                    exportedPackagesData = yield this.t2tcPackageApi.exportPackagesByVersions(packageKeysByVersion, withDependencies);
                 }
                 const exportedPackagesZip = new AdmZip(exportedPackagesData);
                 const manifest = (0, json_1.parse)(exportedPackagesZip.getEntry(batch_export_import_constants_1.BatchExportImportConstants.MANIFEST_FILE_NAME).getData().toString());
                 const versionsByPackageKey = this.getVersionsByPackageKey(manifest);
                 let exportedVariables = yield this.getVersionedVariablesForPackagesWithKeys(versionsByPackageKey);
-                exportedVariables = this.studioService.fixConnectionVariables(exportedVariables);
+                exportedVariables = (0, connection_variable_helper_1.fixConnectionVariables)(exportedVariables);
                 exportedPackagesZip.addFile(batch_export_import_constants_1.BatchExportImportConstants.VARIABLES_FILE_NAME, Buffer.from((0, json_1.stringify)(exportedVariables), "utf8"), "", file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS);
                 const studioPackageKeys = manifest.filter(packageManifest => packageManifest.flavor === batch_export_import_constants_1.BatchExportImportConstants.STUDIO)
                     .map(packageManifest => packageManifest.packageKey);
@@ -125,19 +115,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchExportPackagesMetadata(packageKeys, jsonResponse) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const exportedPackagesMetadata = yield this.batchImportExportApi.batchExportPackagesMetadata(packageKeys);
-                if (jsonResponse) {
-                    this.exportListOfPackagesMetadata(exportedPackagesMetadata);
-                }
-                else {
-                    exportedPackagesMetadata.forEach(pkg => {
-                        logger_1.logger.info(`${pkg.key} - Has Unpublished Changes: ${pkg.hasUnpublishedChanges}`);
-                    });
-                }
-            });
-        }
         batchImportPackages(sourcePath, overwrite, gitBranch, performValidation = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 let sourceToBeImported;
@@ -158,7 +135,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 configs = yield this.studioService.mapSpaces(configs, studioManifests);
                 const existingStudioPackages = yield this.studioPackageApi.findAllPackages();
                 const formData = this.buildBodyForImport(configs, sourceToBeImported, variablesManifests);
-                const postPackageImportData = yield this.batchImportExportApi.importPackages(formData, overwrite, performValidation);
+                const postPackageImportData = yield this.t2tcPackageApi.importPackages(formData, overwrite, performValidation);
                 yield this.studioService.processImportedPackages(configs, existingStudioPackages, studioManifests);
                 if (gitBranch) {
                     fs.rmSync(temporaryGitFolder, { recursive: true });
@@ -171,14 +148,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
         findAndExportListOfActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
-                let packagesToExport = yield this.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
+                let packagesToExport = yield this.t2tcPackageApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
                 packagesToExport = yield this.studioService.getExportPackagesWithStudioData(packagesToExport, false);
                 this.exportListOfPackages(packagesToExport);
             });
         }
         listActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches) {
             return __awaiter(this, void 0, void 0, function* () {
-                const packagesByVariableValue = yield this.batchImportExportApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
+                const packagesByVariableValue = yield this.t2tcPackageApi.findActivePackagesByVariableValue(flavors, variableValue, variableType, includeBranches);
                 packagesByVariableValue.forEach(pkg => {
                     logger_1.logger.info(`${pkg.name} - Key: "${pkg.key}"`);
                 });
@@ -206,12 +183,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     });
                 });
             });
-            return this.batchImportExportApi.findVariablesWithValuesByPackageKeysAndVersion(variableExportRequest);
-        }
-        exportListOfPackagesMetadata(packagesMetadata) {
-            const filename = (0, uuid_1.v4)() + ".json";
-            file_service_1.fileService.writeToFileWithGivenName(JSON.stringify(packagesMetadata), filename);
-            logger_1.logger.info(file_service_1.FileService.fileDownloadedMessage + filename);
+            return this.variableApi.findVariablesWithValuesByPackageKeysAndVersion(variableExportRequest);
         }
         buildBodyForImport(configs, sourcePath, variablesManifests) {
             const formData = new FormData();
@@ -262,5 +234,5 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             }
         }
     }
-    exports.BatchImportExportService = BatchImportExportService;
+    exports.T2tcPackageService = T2tcPackageService;
 });

package/commands/view/module.js

@@ -0,0 +1,54 @@
+/**
+ * Commands related to the View feature.
+ */
+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());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../core/command/module-handler", "./view-bookmarks-command.service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    const module_handler_1 = require("../../core/command/module-handler");
+    const view_bookmarks_command_service_1 = require("./view-bookmarks-command.service");
+    class Module extends module_handler_1.IModule {
+        register(context, configurator) {
+            const pullCommand = configurator.command("pull");
+            pullCommand
+                .command("view-bookmarks")
+                .description("Command to pull view bookmarks")
+                .option("--type <type>", "Type of view bookmarks to pull: USER (default), SHARED, or ALL")
+                .requiredOption("--id <id>", "ID of the view (board) to pull bookmarks from")
+                .action(this.pullViewBookmarks);
+            const pushCommand = configurator.command("push");
+            pushCommand
+                .command("view-bookmarks")
+                .description("Command to push view bookmarks to a board")
+                .requiredOption("--id <id>", "ID of the view (board) to push bookmarks into")
+                .requiredOption("-f, --file <file>", "The file to push")
+                .action(this.pushViewBookmarks);
+        }
+        pullViewBookmarks(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new view_bookmarks_command_service_1.ViewBookmarksCommandService(context).pullViewBookmarks(options.id, options.type);
+            });
+        }
+        pushViewBookmarks(context, command, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield new view_bookmarks_command_service_1.ViewBookmarksCommandService(context).pushViewBookmarks(options.id, options.file);
+            });
+        }
+    }
+    return Module;
+});

package/commands/view/view-bookmarks-command.service.js

@@ -0,0 +1,45 @@
+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());
+    });
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./view-bookmarks.manager-factory", "../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ViewBookmarksCommandService = void 0;
+    const view_bookmarks_manager_factory_1 = require("./view-bookmarks.manager-factory");
+    const logger_1 = require("../../core/utils/logger");
+    const ALLOWED_VIEW_BOOKMARK_TYPES = ["USER", "SHARED", "ALL"];
+    class ViewBookmarksCommandService {
+        constructor(context) {
+            this.viewBookmarksManagerFactory = new view_bookmarks_manager_factory_1.ViewBookmarksManagerFactory(context);
+        }
+        pullViewBookmarks(boardId, type) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (type !== undefined && !ALLOWED_VIEW_BOOKMARK_TYPES.includes(type.toUpperCase())) {
+                    logger_1.logger.error(new logger_1.FatalError(`Invalid type "${type}". Allowed values are: ${ALLOWED_VIEW_BOOKMARK_TYPES.join(", ")}.`));
+                    return;
+                }
+                yield this.viewBookmarksManagerFactory.createViewBookmarksManager(null, boardId, type).pull();
+            });
+        }
+        pushViewBookmarks(boardId, filename) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.viewBookmarksManagerFactory.createViewBookmarksManager(filename, boardId).push();
+            });
+        }
+    }
+    exports.ViewBookmarksCommandService = ViewBookmarksCommandService;
+});

package/commands/view/view-bookmarks.manager-factory.js

@@ -0,0 +1,39 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "node:fs", "node:path", "./view-bookmarks.manager", "../../core/utils/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ViewBookmarksManagerFactory = void 0;
+    const fs = require("node:fs");
+    const path = require("node:path");
+    const view_bookmarks_manager_1 = require("./view-bookmarks.manager");
+    const logger_1 = require("../../core/utils/logger");
+    class ViewBookmarksManagerFactory {
+        constructor(context) {
+            this.context = context;
+        }
+        createViewBookmarksManager(filename, boardId, type) {
+            const viewBookmarksManager = new view_bookmarks_manager_1.ViewBookmarksManager(this.context);
+            viewBookmarksManager.boardId = boardId;
+            type = (type !== null && type !== void 0 ? type : "USER").toUpperCase();
+            viewBookmarksManager.type = type;
+            if (filename !== null) {
+                viewBookmarksManager.filePath = this.resolveFilePath(filename);
+            }
+            return viewBookmarksManager;
+        }
+        resolveFilePath(fileName) {
+            if (!fs.existsSync(path.resolve(process.cwd(), fileName))) {
+                logger_1.logger.error(new logger_1.FatalError("The provided file does not exist"));
+            }
+            return path.resolve(process.cwd(), fileName);
+        }
+    }
+    exports.ViewBookmarksManagerFactory = ViewBookmarksManagerFactory;
+});

package/commands/view/view-bookmarks.manager.js

@@ -0,0 +1,60 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "node:fs", "form-data", "../../core/http/http-shared/base.manager"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ViewBookmarksManager = void 0;
+    const fs = require("node:fs");
+    const FormData = require("form-data");
+    const base_manager_1 = require("../../core/http/http-shared/base.manager");
+    class ViewBookmarksManager extends base_manager_1.BaseManager {
+        constructor(context) {
+            super(context);
+        }
+        get filePath() {
+            return this._filePath;
+        }
+        set filePath(value) {
+            this._filePath = value;
+        }
+        get boardId() {
+            return this._boardId;
+        }
+        set boardId(value) {
+            this._boardId = value;
+        }
+        get type() {
+            return this._type;
+        }
+        set type(value) {
+            this._type = value;
+        }
+        getConfig() {
+            return {
+                pushUrl: `${ViewBookmarksManager.BASE_URL}/import?boardId=${encodeURIComponent(this.boardId)}`,
+                pullUrl: `${ViewBookmarksManager.BASE_URL}/export?boardId=${encodeURIComponent(this.boardId)}&type=${encodeURIComponent(this.type)}`,
+                exportFileName: `${ViewBookmarksManager.VIEW_BOOKMARKS_FILE_PREFIX}${this.boardId}.json`,
+                onPushSuccessMessage: () => {
+                    return "View Bookmarks were pushed successfully.";
+                },
+            };
+        }
+        getBody() {
+            const formData = new FormData();
+            formData.append("file", fs.createReadStream(this.filePath));
+            return formData;
+        }
+        getSerializedFileContent(data) {
+            return JSON.stringify(data);
+        }
+    }
+    exports.ViewBookmarksManager = ViewBookmarksManager;
+    ViewBookmarksManager.BASE_URL = "/blueprint/api/bookmarks";
+    ViewBookmarksManager.VIEW_BOOKMARKS_FILE_PREFIX = "studio_view_bookmarks_";
+});

package/core/utils/file-service.js

@@ -95,6 +95,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             finalZip.writeZip(zipFilePath, () => fs.chmodSync(zipFilePath, file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS));
             return zipFilePath;
         }
+        zipDirectoryAsSinglePackage(sourceDir) {
+            if (fs.lstatSync(sourceDir).isSymbolicLink()) {
+                throw new logger_1.FatalError("Source directory cannot be a symbolic link.");
+            }
+            const zip = new AdmZip();
+            zip.addLocalFolder(sourceDir);
+            const tempDir = path.join(os.tmpdir(), "content-cli-imports");
+            fs.mkdirSync(tempDir, { recursive: true, mode: file_constants_1.FileConstants.DEFAULT_FOLDER_PERMISSIONS });
+            const zipFilePath = path.join(tempDir, `single_package_${(0, uuid_1.v4)()}.zip`);
+            zip.writeZip(zipFilePath, () => fs.chmodSync(zipFilePath, file_constants_1.FileConstants.DEFAULT_FILE_PERMISSIONS));
+            return zipFilePath;
+        }
         getSerializedFileContent(data) {
             return data;
         }

package/lib/commands/configuration-management/api/metadata-api.d.ts

@@ -0,0 +1,7 @@
+import { PackageMetadataExportTransport } from "../interfaces/package-export.interfaces";
+import { Context } from "../../../core/command/cli-context";
+export declare class MetadataApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    exportPackagesMetadata(packageKeys: string[]): Promise<PackageMetadataExportTransport[]>;
+}

package/lib/commands/configuration-management/api/single-package-import-api.d.ts

@@ -0,0 +1,8 @@
+import * as FormData from "form-data";
+import { Context } from "../../../core/command/cli-context";
+import { SinglePackageImportResult } from "../interfaces/single-package-import.interfaces";
+export declare class SinglePackageImportApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    importPackage(data: FormData, overwrite: boolean): Promise<SinglePackageImportResult>;
+}

package/lib/commands/configuration-management/api/staging-package-api.d.ts

@@ -0,0 +1,7 @@
+import { PackageExportTransport } from "../interfaces/package-export.interfaces";
+import { Context } from "../../../core/command/cli-context";
+export declare class StagingPackageApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    findAllStagingPackages(flavors: string[], includeBranches?: boolean): Promise<PackageExportTransport[]>;
+}

package/lib/commands/configuration-management/api/variable-api.d.ts

@@ -0,0 +1,7 @@
+import { PackageKeyAndVersionPair, VariableManifestTransport } from "../interfaces/package-export.interfaces";
+import { Context } from "../../../core/command/cli-context";
+export declare class VariableApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion: PackageKeyAndVersionPair[]): Promise<VariableManifestTransport[]>;
+}

package/lib/commands/configuration-management/config-command.service.d.ts

@@ -1,14 +1,6 @@
 import { Context } from "../../core/command/cli-context";
 export declare class ConfigCommandService {
-    private batchImportExportService;
     private variableService;
-    private diffService;
     constructor(context: Context);
-    listPackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[], keysByVersion: string[], variableValue: string, variableType: string, includeBranches: boolean, staging: boolean): Promise<void>;
     listVariables(jsonResponse: boolean, keysByVersion: string[], keysByVersionFile: string, packageKeys: string[]): Promise<void>;
-    batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean, gitBranch: string, unzip: boolean): Promise<void>;
-    batchExportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;
-    batchImportPackages(file: string, directory: string, overwrite: boolean, gitBranch: string, performValidation?: boolean): Promise<void>;
-    diffPackages(file: string, hasChanges: boolean, jsonResponse: boolean): Promise<void>;
-    private listPackagesByVariableValue;
 }

package/lib/commands/configuration-management/connection-variable.helper.d.ts

@@ -0,0 +1,2 @@
+import { VariableManifestTransport } from "./interfaces/package-export.interfaces";
+export declare function fixConnectionVariables(variables: VariableManifestTransport[]): VariableManifestTransport[];

package/lib/commands/configuration-management/interfaces/single-package-import.interfaces.d.ts

@@ -0,0 +1,19 @@
+import { NodeTransport } from "./node.interfaces";
+export interface PackageTransport {
+    id: string;
+    key: string;
+    name: string;
+    type?: string;
+    version?: string;
+    flavor?: string;
+    schemaVersion?: number;
+    createdBy?: string;
+    updatedBy?: string;
+    creationDate?: string;
+    changeDate?: string;
+    [key: string]: any;
+}
+export interface SinglePackageImportResult {
+    importedPackage: PackageTransport;
+    importedNodes: NodeTransport[];
+}

package/lib/commands/configuration-management/metadata.service.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../core/command/cli-context";
+export declare class MetadataService {
+    private metadataApi;
+    constructor(context: Context);
+    exportPackagesMetadata(packageKeys: string[], jsonResponse: boolean): Promise<void>;
+    private exportListOfPackagesMetadata;
+}

package/lib/commands/configuration-management/module.d.ts

@@ -6,11 +6,13 @@ import { Context } from "../../core/command/cli-context";
 declare class Module extends IModule {
     register(context: Context, configurator: Configurator): void;
     private listPackages;
+    private listStagingPackages;
     private batchExportPackages;
-    private batchExportPackagesMetadata;
+    private exportPackagesMetadata;
     private getPackageVersion;
     private createPackageVersion;
     private batchImportPackages;
+    private importSinglePackage;
     private diffPackages;
     private validatePackage;
     private listVariables;

package/lib/commands/configuration-management/single-package-import.service.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "../../core/command/cli-context";
+export declare class SinglePackageImportService {
+    private static readonly MAX_UNCOMPRESSED_ZIP_SIZE;
+    private readonly singlePackageImportApi;
+    constructor(context: Context);
+    importPackage(file: string, directory: string, overwrite: boolean, jsonResponse: boolean): Promise<void>;
+    private resolveSource;
+    private buildBodyForImport;
+    private assertUncompressedSizeWithinLimit;
+    private getReadableStream;
+    private outputResult;
+}

package/lib/commands/configuration-management/staging-package.service.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../core/command/cli-context";
+export declare class StagingPackageService {
+    private stagingPackageApi;
+    constructor(context: Context);
+    listStagingPackages(flavors: string[], includeBranches: boolean, jsonResponse: boolean): Promise<void>;
+    private exportListOfPackages;
+}

package/lib/commands/configuration-management/variable.service.d.ts

@@ -1,9 +1,8 @@
 import { Context } from "../../core/command/cli-context";
 export declare class VariableService {
-    private batchImportExportApi;
+    private variableApi;
     private variableAssignmentCandidatesApi;
     private readonly stagingPackageVariablesApi;
-    private studioService;
     constructor(context: Context);
     listVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
     listCandidateAssignments(type: string, params: string): Promise<void>;

package/lib/commands/t2tc/api/diff-api.d.ts

@@ -0,0 +1,9 @@
+import * as FormData from "form-data";
+import { Context } from "../../../core/command/cli-context";
+import { PackageDiffMetadata, PackageDiffTransport } from "../../configuration-management/interfaces/diff-package.interfaces";
+export declare class DiffApi {
+    private readonly httpClient;
+    constructor(context: Context);
+    diffPackages(baseVersion: string, data: FormData): Promise<PackageDiffTransport[]>;
+    hasChanges(baseVersion: string, data: FormData): Promise<PackageDiffMetadata[]>;
+}

package/lib/commands/{configuration-management/api/batch-import-export-api.d.ts → t2tc/api/t2tc-package-api.d.ts}

@@ -1,18 +1,15 @@
 /// <reference types="node" />
 import * as FormData from "form-data";
-import { PackageExportTransport, PackageKeyAndVersionPair, PackageMetadataExportTransport, PostPackageImportData, VariableManifestTransport } from "../interfaces/package-export.interfaces";
+import { PackageExportTransport, PostPackageImportData } from "../../configuration-management/interfaces/package-export.interfaces";
 import { Context } from "../../../core/command/cli-context";
-export declare class BatchImportExportApi {
-    private httpClient;
+export declare class T2tcPackageApi {
+    private readonly httpClient;
     constructor(context: Context);
     findAllActivePackages(flavors: string[], withDependencies?: boolean, includeBranches?: boolean): Promise<PackageExportTransport[]>;
-    findAllStagingPackages(flavors: string[], includeBranches?: boolean): Promise<PackageExportTransport[]>;
     findActivePackagesByVariableValue(flavors: string[], variableValue: string, variableType: string, includeBranches?: boolean): Promise<PackageExportTransport[]>;
     findActivePackagesByKeys(packageKeys: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
     findPackagesByKeysAndVersion(packageKeysWithVersion: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
     exportPackages(packageKeys: string[], withDependencies: boolean): Promise<Buffer>;
     exportPackagesByVersions(packageKeysWithVersion: string[], withDependencies: boolean): Promise<Buffer>;
-    batchExportPackagesMetadata(packageKeys: string[]): Promise<PackageMetadataExportTransport[]>;
     importPackages(data: FormData, overwrite: boolean, performValidation: boolean): Promise<PostPackageImportData[]>;
-    findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion: PackageKeyAndVersionPair[]): Promise<VariableManifestTransport[]>;
 }

package/lib/commands/{configuration-management → t2tc}/diff.service.d.ts

@@ -2,7 +2,7 @@ import { Context } from "../../core/command/cli-context";
 export declare class DiffService {
     private diffApi;
     constructor(context: Context);
-    diffPackages(file: string, hasChanges: boolean, jsonResponse: boolean): Promise<void>;
+    diffPackages(file: string, hasChanges: boolean, baseVersion: string, jsonResponse: boolean): Promise<void>;
     private hasChanges;
     private diffPackagesAndReturnDiff;
     private buildBodyForDiff;

package/lib/commands/t2tc/module.d.ts

@@ -0,0 +1,10 @@
+import { Configurator, IModule } from "../../core/command/module-handler";
+import { Context } from "../../core/command/cli-context";
+declare class Module extends IModule {
+    register(context: Context, configurator: Configurator): void;
+    private listPackages;
+    private batchExportPackages;
+    private batchImportPackages;
+    private diffPackages;
+}
+export = Module;

package/lib/commands/{configuration-management → t2tc}/studio.service.d.ts

@@ -1,6 +1,6 @@
 import { IZipEntry } from "adm-zip";
 import * as AdmZip from "adm-zip";
-import { PackageExportTransport, StudioPackageManifest, VariableManifestTransport } from "./interfaces/package-export.interfaces";
+import { PackageExportTransport, StudioPackageManifest, VariableManifestTransport } from "../configuration-management/interfaces/package-export.interfaces";
 import { ContentNodeTransport } from "../studio/interfaces/package-manager.interfaces";
 import { Context } from "../../core/command/cli-context";
 export declare class StudioService {
@@ -13,13 +13,11 @@ export declare class StudioService {
     private studioVariableService;
     constructor(context: Context);
     getExportPackagesWithStudioData(packagesToExport: PackageExportTransport[], withDependencies: boolean): Promise<PackageExportTransport[]>;
-    fixConnectionVariables(variables: VariableManifestTransport[]): VariableManifestTransport[];
     getStudioPackageManifests(studioPackageKeys: string[]): Promise<StudioPackageManifest[]>;
     processPackageForExport(exportedPackage: IZipEntry, exportedVariables: VariableManifestTransport[]): AdmZip;
     processImportedPackages(configs: AdmZip, existingStudioPackages: ContentNodeTransport[], studioManifests: StudioPackageManifest[]): Promise<void>;
     private setSpaceIdForStudioPackages;
     private setDataModelsForStudioPackages;
-    private fixConnectionVariable;
     private deleteScenarioAssets;
     private fixConnectionVariablesForRootNodeFiles;
     private getPackageKeyAndVersion;

package/lib/commands/t2tc/t2tc-command.service.d.ts

@@ -0,0 +1,12 @@
+import { Context } from "../../core/command/cli-context";
+export declare class T2tcCommandService {
+    private t2tcPackageService;
+    private diffService;
+    private stagingPackageService;
+    constructor(context: Context);
+    listPackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[], keysByVersion: string[], variableValue: string, variableType: string, includeBranches: boolean, staging: boolean): Promise<void>;
+    batchExportPackages(packageKeys: string[], packageKeysByVersion: string[], withDependencies: boolean, gitBranch: string, unzip: boolean): Promise<void>;
+    batchImportPackages(file: string, directory: string, overwrite: boolean, gitBranch: string, performValidation?: boolean): Promise<void>;
+    diffPackages(file: string, hasChanges: boolean, baseVersion: string, jsonResponse: boolean): Promise<void>;
+    private listPackagesByVariableValue;
+}