@celonis/content-cli 0.6.1 → 0.8.0

package/api/batch-import-export-api.js

@@ -0,0 +1,51 @@
+(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", "../services/http-client-service.v2", "../util/logger"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.batchImportExportApi = void 0;
+    const http_client_service_v2_1 = require("../services/http-client-service.v2");
+    const logger_1 = require("../util/logger");
+    class BatchImportExportApi {
+        findAllActivePackages(flavors, withDependencies = false) {
+            const queryParams = new URLSearchParams();
+            queryParams.set("withDependencies", withDependencies.toString());
+            flavors.forEach(flavor => queryParams.append("flavors", flavor));
+            return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/core/packages/export/list?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem getting active packages: ${e}`);
+            });
+        }
+        findActivePackagesByKeys(packageKeys, withDependencies = false) {
+            const queryParams = new URLSearchParams();
+            packageKeys.forEach(key => queryParams.append("packageKeys", key));
+            queryParams.set("withDependencies", withDependencies.toString());
+            return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/core/packages/export/list-by-keys?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem getting active packages by keys: ${e}`);
+            });
+        }
+        exportPackages(packageKeys, withDependencies = false) {
+            const queryParams = new URLSearchParams();
+            packageKeys.forEach(packageKey => queryParams.append("packageKeys", packageKey));
+            queryParams.set("withDependencies", withDependencies.toString());
+            return http_client_service_v2_1.httpClientV2.getFile(`/package-manager/api/core/packages/export/batch?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem exporting packages: ${e}`);
+            });
+        }
+        importPackages(data, overwrite) {
+            return http_client_service_v2_1.httpClientV2.postFile("/package-manager/api/core/packages/import/batch", data, { overwrite });
+        }
+        findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion) {
+            return http_client_service_v2_1.httpClientV2.post("/package-manager/api/core/packages/export/batch/variables-with-assignments", packagesByKeyAndVersion).catch(e => {
+                throw new logger_1.FatalError(`Problem exporting package variables: ${e}`);
+            });
+        }
+    }
+    BatchImportExportApi.INSTANCE = new BatchImportExportApi();
+    exports.batchImportExportApi = BatchImportExportApi.INSTANCE;
+});

package/api/package-api.js

@@ -29,11 +29,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        exportPackage(rootPackageKey, version) {
+        exportPackage(rootPackageKey, version, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
                 const queryParams = new URLSearchParams();
                 queryParams.set("newKey", rootPackageKey);
                 queryParams.set("version", version !== null && version !== void 0 ? version : "");
+                queryParams.set("excludeActionFlows", excludeActionFlows ? "true" : "false");
                 return yield http_client_service_v2_1.httpClientV2.downloadFile(`/package-manager/api/packages/${rootPackageKey}/export?${queryParams.toString()}`).catch(e => {
                     throw new logger_1.FatalError(`Pacakge ${rootPackageKey}_${version} failed to export.`);
                 });
@@ -78,11 +79,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
-        importPackage(nodeContent, spaceId, overwrite) {
+        importPackage(nodeContent, spaceId, overwrite, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
                 yield http_client_service_v2_1.httpClientV2.postFile("/package-manager/api/packages/import", nodeContent, {
                     spaceId: spaceId,
-                    overwrite: overwrite
+                    overwrite: overwrite,
+                    excludeActionFlows: excludeActionFlows
                 }).catch(e => {
                     throw new logger_1.FatalError(`Problem importing package: ${e}`);
                 });

package/api/variables-api.js

@@ -13,7 +13,7 @@ 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", "../services/http-client-service.v2", "../util/logger", "./variable-assignment-apis"], factory);
+        define(["require", "exports", "../services/http-client-service.v2", "../util/logger", "./variable-assignment-apis", "url"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -22,6 +22,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     const http_client_service_v2_1 = require("../services/http-client-service.v2");
     const logger_1 = require("../util/logger");
     const variable_assignment_apis_1 = require("./variable-assignment-apis");
+    const url_1 = require("url");
     class VariablesApi {
         assignVariableValues(packageKey, variablesAssignments) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -41,6 +42,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 });
             });
         }
+        getRuntimeVariableValues(packageKey, appMode) {
+            const queryParams = new url_1.URLSearchParams();
+            queryParams.set("appMode", appMode);
+            return http_client_service_v2_1.httpClientV2.get(`/package-manager/api/nodes/by-package-key/${packageKey}/variables/runtime-values?${queryParams.toString()}`).catch(e => {
+                throw new logger_1.FatalError(`Problem getting runtime variables of package ${packageKey}: ${e}`);
+            });
+        }
     }
     VariablesApi.INSTANCE = new VariablesApi();
     VariablesApi.ASSIGNMENT_APIS = variable_assignment_apis_1.variableAssignmentApis;

package/commands/config.command.js

@@ -0,0 +1,53 @@
+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", "../services/package-manager/batch-import-export-service", "../services/package-manager/variable-service"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ConfigCommand = void 0;
+    const batch_import_export_service_1 = require("../services/package-manager/batch-import-export-service");
+    const variable_service_1 = require("../services/package-manager/variable-service");
+    class ConfigCommand {
+        listActivePackages(jsonResponse, flavors, withDependencies, packageKeys) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (jsonResponse) {
+                    yield batch_import_export_service_1.batchImportExportService.findAndExportListOfActivePackages(flavors !== null && flavors !== void 0 ? flavors : [], packageKeys !== null && packageKeys !== void 0 ? packageKeys : [], withDependencies);
+                }
+                else {
+                    yield batch_import_export_service_1.batchImportExportService.listActivePackages(flavors !== null && flavors !== void 0 ? flavors : []);
+                }
+            });
+        }
+        listVariables(jsonResponse, keysByVersion, keysByVersionFile) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (jsonResponse) {
+                    yield variable_service_1.variableService.exportVariables(keysByVersion, keysByVersionFile);
+                }
+                else {
+                    yield variable_service_1.variableService.listVariables(keysByVersion, keysByVersionFile);
+                }
+            });
+        }
+        batchExportPackages(packageKeys, withDependencies = false) {
+            return batch_import_export_service_1.batchImportExportService.batchExportPackages(packageKeys, withDependencies);
+        }
+        batchImportPackages(file, overwrite) {
+            return batch_import_export_service_1.batchImportExportService.batchImportPackages(file, overwrite);
+        }
+    }
+    exports.ConfigCommand = ConfigCommand;
+});

package/commands/package.command.js

@@ -52,14 +52,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
             });
         }
-        batchExportPackages(packageKeys, includeDependencies) {
+        batchExportPackages(packageKeys, includeDependencies, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield package_service_1.packageService.batchExportPackages(packageKeys, includeDependencies);
+                yield package_service_1.packageService.batchExportPackages(packageKeys, includeDependencies, excludeActionFlows);
             });
         }
-        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite) {
+        batchImportPackages(spaceMappings, dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows) {
             return __awaiter(this, void 0, void 0, function* () {
-                yield package_service_1.packageService.batchImportPackages(spaceMappings !== null && spaceMappings !== void 0 ? spaceMappings : [], dataModelMappingsFilePath, exportedPackagesFile, overwrite);
+                yield package_service_1.packageService.batchImportPackages(spaceMappings !== null && spaceMappings !== void 0 ? spaceMappings : [], dataModelMappingsFilePath, exportedPackagesFile, overwrite, excludeActionFlows);
             });
         }
     }

package/content-cli-config.js

@@ -0,0 +1,102 @@
+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", "./commands/config.command", "commander", "./util/logger", "./util/context-initializer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Config = void 0;
+    const config_command_1 = require("./commands/config.command");
+    const commander = require("commander");
+    const logger_1 = require("./util/logger");
+    const context_initializer_1 = require("./util/context-initializer");
+    class Config {
+        static list(program) {
+            program
+                .command("list")
+                .description("Command to list active packages that can be exported")
+                .option("-p, --profile <profile>", "Profile which you want to use to list possible variable assignments")
+                .option("--json", "Return response as json type", "")
+                .option("--flavors <flavors...>", "Lists only active packages of the given flavors")
+                .option("--withDependencies", "Include dependencies", "")
+                .option("--packageKeys <packageKeys...>", "Lists only given package keys")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().listActivePackages(cmd.json, cmd.flavors, cmd.withDependencies, cmd.packageKeys);
+                process.exit();
+            }));
+            return program;
+        }
+        static listVariables(program) {
+            program
+                .command("variables")
+                .description("Commands related to variable configs")
+                .command("list")
+                .description("Command to list versioned variables of packages")
+                .option("-p, --profile <profile>", "Profile which you want to use to list packages")
+                .option("--json", "Return response as json type", "")
+                .option("--keysByVersion <keysByVersion...>", "Mapping of package keys and versions", "")
+                .option("--keysByVersionFile <keysByVersionFile>", "Package keys by version mappings file path.", "")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().listVariables(cmd.json, cmd.keysByVersion, cmd.keysByVersionFile);
+                process.exit();
+            }));
+            return program;
+        }
+        static export(program) {
+            program
+                .command("export")
+                .description("Command to export package configs")
+                .option("-p, --profile <profile>", "Profile which you want to use to export packages")
+                .requiredOption("--packageKeys <packageKeys...>", "Keys of packages to export")
+                .option("--withDependencies", "Include variables and dependencies", "")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().batchExportPackages(cmd.packageKeys, cmd.withDependencies);
+                process.exit();
+            }));
+            return program;
+        }
+        static import(program) {
+            program
+                .command("import")
+                .description("Command to import package configs")
+                .option("-p, --profile <profile>", "Profile which you want to use to import packages")
+                .option("--overwrite", "Flag to allow overwriting of packages")
+                .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
+                .action((cmd) => __awaiter(this, void 0, void 0, function* () {
+                yield new config_command_1.ConfigCommand().batchImportPackages(cmd.file, cmd.overwrite);
+                process.exit();
+            }));
+            return program;
+        }
+    }
+    exports.Config = Config;
+    const loadAllCommands = () => {
+        Config.list(commander);
+        Config.listVariables(commander);
+        Config.export(commander);
+        Config.import(commander);
+        commander.parse(process.argv);
+    };
+    context_initializer_1.ContextInitializer.initContext()
+        .then(loadAllCommands, loadAllCommands)
+        .catch(e => {
+        logger_1.logger.error(e);
+    });
+    if (!process.argv.slice(2).length) {
+        commander.outputHelp();
+        process.exit(1);
+    }
+});

package/content-cli-export.js

@@ -32,8 +32,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("-p, --profile <profile>", "Profile which you want to use to list packages")
                 .requiredOption("--packageKeys <packageKeys...>", "Exports only given package keys")
                 .option("--includeDependencies", "Include variables and dependencies", "")
+                .option("--excludeActionFlows", "Don't export action flows")
                 .action((cmd) => __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_1.PackageCommand().batchExportPackages(cmd.packageKeys, cmd.includeDependencies);
+                var _a;
+                yield new package_command_1.PackageCommand().batchExportPackages(cmd.packageKeys, cmd.includeDependencies, (_a = cmd.excludeActionFlows) !== null && _a !== void 0 ? _a : false);
                 process.exit();
             }));
             return program;

package/content-cli-import.js

@@ -32,10 +32,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 .option("-p, --profile <profile>", "Profile which you want to use to list packages")
                 .option("--spaceMappings <spaceMappings...>", "List of mappings for importing packages to different target spaces. Mappings should follow format 'packageKey:targetSpaceKey'")
                 .option("--overwrite", "Flag to allow overwriting of packages")
+                .option("--excludeActionFlows", "Skip overwrite of action flows of package")
                 .option("--dataModelMappingsFile <dataModelMappingsFile>", "DataModel variable mappings file path. If missing, variables will be mapped from manifest file.")
                 .requiredOption("-f, --file <file>", "Exported packages file (relative path)")
                 .action((cmd) => __awaiter(this, void 0, void 0, function* () {
-                yield new package_command_1.PackageCommand().batchImportPackages(cmd.spaceMappings, cmd.dataModelMappingsFile, cmd.file, cmd.overwrite);
+                yield new package_command_1.PackageCommand().batchImportPackages(cmd.spaceMappings, cmd.dataModelMappingsFile, cmd.file, cmd.overwrite, cmd.excludeActionFlows);
                 process.exit();
             }));
             return program;

package/content-cli-list.js

@@ -108,9 +108,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         }
     }
     exports.List = List;
-    process.on("unhandledRejection", (e, promise) => {
-        logger_1.logger.error(e.toString());
-    });
     const loadAllCommands = () => {
         List.packages(commander);
         List.spaces(commander);
@@ -121,7 +118,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         commander.parse(process.argv);
     };
     context_initializer_1.ContextInitializer.initContext()
-        .then(loadAllCommands)
+        .then(loadAllCommands, loadAllCommands)
         .catch(e => {
         logger_1.logger.error(e);
     });

package/content-cli-set.js

@@ -39,11 +39,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
             return program;
         }
     }
-    context_initializer_1.ContextInitializer.initContext()
-        .then(() => {
+    const loadAllCommands = () => {
         Set.connection(commander);
         commander.parse(process.argv);
-    })
+    };
+    context_initializer_1.ContextInitializer.initContext()
+        .then(loadAllCommands, loadAllCommands)
         .catch(e => {
         logger_1.logger.error(e);
     });

package/content-cli.js

@@ -28,6 +28,7 @@
     program.command("list", "Commands to list content.").alias("ls");
     program.command("get", "Commands to get configuration properties.");
     program.command("set", "Commands to set configuration properties.");
+    program.command("config", "Commands related to config management.");
     program.version(version_1.VersionUtils.getCurrentCliVersion());
     program.parse(process.argv);
     if (!process.argv.slice(2).length) {

package/interfaces/batch-export-import-constants.js

@@ -0,0 +1,25 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BatchExportImportConstants = void 0;
+    var BatchExportImportConstants;
+    (function (BatchExportImportConstants) {
+        BatchExportImportConstants["STUDIO_FILE_NAME"] = "studio.yml";
+        BatchExportImportConstants["VARIABLES_FILE_NAME"] = "variables.yml";
+        BatchExportImportConstants["MANIFEST_FILE_NAME"] = "manifest.yml";
+        BatchExportImportConstants["STUDIO"] = "STUDIO";
+        BatchExportImportConstants["APP_MODE_VIEWER"] = "VIEWER";
+        BatchExportImportConstants["ZIP_EXTENSION"] = ".zip";
+        BatchExportImportConstants["YAML_EXTENSION"] = ".yml";
+        BatchExportImportConstants["NODES_FOLDER_NAME"] = "nodes/";
+        BatchExportImportConstants["SCENARIO_NODE"] = "SCENARIO";
+    })(BatchExportImportConstants || (exports.BatchExportImportConstants = BatchExportImportConstants = {}));
+});

package/interfaces/package-export-transport.js

@@ -0,0 +1,12 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});

package/lib/api/batch-import-export-api.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { PackageExportTransport, PackageKeyAndVersionPair, PostPackageImportData, VariableManifestTransport } from "../interfaces/package-export-transport";
+import * as FormData from "form-data";
+declare class BatchImportExportApi {
+    static readonly INSTANCE: BatchImportExportApi;
+    findAllActivePackages(flavors: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
+    findActivePackagesByKeys(packageKeys: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
+    exportPackages(packageKeys: string[], withDependencies?: boolean): Promise<Buffer>;
+    importPackages(data: FormData, overwrite: boolean): Promise<PostPackageImportData[]>;
+    findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion: PackageKeyAndVersionPair[]): Promise<VariableManifestTransport[]>;
+}
+export declare const batchImportExportApi: BatchImportExportApi;
+export {};

package/lib/api/package-api.d.ts

@@ -3,13 +3,13 @@ import { ActivatePackageTransport, ContentNodeTransport, PackageHistoryTransport
 declare class PackageApi {
     static readonly INSTANCE: PackageApi;
     findAllPackages(): Promise<ContentNodeTransport[]>;
-    exportPackage(rootPackageKey: string, version?: string): Promise<Buffer>;
+    exportPackage(rootPackageKey: string, version?: string, excludeActionFlows?: boolean): Promise<Buffer>;
     findAllPackagesWithVariableAssignments(type: PackageManagerVariableType): Promise<PackageWithVariableAssignments[]>;
     findLatestVersionById(nodeId: string): Promise<PackageHistoryTransport>;
     findActiveVersionById(nodeId: string): Promise<PackageHistoryTransport>;
     findActiveVersionByIds(nodeIds: string[]): Promise<PackageHistoryTransport[]>;
     findNextVersion(nodeId: string): Promise<PackageHistoryTransport>;
-    importPackage(nodeContent: any, spaceId: string, overwrite: boolean): Promise<any>;
+    importPackage(nodeContent: any, spaceId: string, overwrite: boolean, excludeActionFlows?: boolean): Promise<any>;
     movePackageToSpace(nodeId: string, spaceId: string): Promise<void>;
     publishPackage(activatePackage: ActivatePackageTransport): Promise<void>;
 }

package/lib/api/variables-api.d.ts

@@ -8,6 +8,7 @@ declare class VariablesApi {
     };
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<ContentNodeTransport[]>;
     getCandidateAssignments(type: string, params: URLSearchParams): Promise<object[]>;
+    getRuntimeVariableValues(packageKey: string, appMode: string): Promise<VariablesAssignments[]>;
 }
 export declare const variablesApi: VariablesApi;
 export {};

package/lib/commands/config.command.d.ts

@@ -0,0 +1,6 @@
+export declare class ConfigCommand {
+    listActivePackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[]): Promise<void>;
+    listVariables(jsonResponse: boolean, keysByVersion: string[], keysByVersionFile: string): Promise<void>;
+    batchExportPackages(packageKeys: string[], withDependencies?: boolean): Promise<void>;
+    batchImportPackages(file: string, overwrite: boolean): Promise<void>;
+}

package/lib/commands/package.command.d.ts

@@ -5,6 +5,6 @@ export declare class PackageCommand {
     pushPackage(profile: string, spaceKey: string, fileName: string, newKey: string, overwrite: boolean): Promise<void>;
     pushPackages(profile: string, spaceKey: string): Promise<void>;
     listPackages(jsonResponse: boolean, includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean): Promise<void>;
+    batchExportPackages(packageKeys: string[], includeDependencies: boolean, excludeActionFlows?: boolean): Promise<void>;
+    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean, excludeActionFlows?: boolean): Promise<void>;
 }

package/lib/content-cli-config.d.ts

@@ -0,0 +1,9 @@
+import commander = require("commander");
+type CommanderStatic = commander.CommanderStatic;
+export declare class Config {
+    static list(program: CommanderStatic): CommanderStatic;
+    static listVariables(program: CommanderStatic): CommanderStatic;
+    static export(program: CommanderStatic): CommanderStatic;
+    static import(program: CommanderStatic): CommanderStatic;
+}
+export {};

package/lib/interfaces/batch-export-import-constants.d.ts

@@ -0,0 +1,11 @@
+export declare enum BatchExportImportConstants {
+    STUDIO_FILE_NAME = "studio.yml",
+    VARIABLES_FILE_NAME = "variables.yml",
+    MANIFEST_FILE_NAME = "manifest.yml",
+    STUDIO = "STUDIO",
+    APP_MODE_VIEWER = "VIEWER",
+    ZIP_EXTENSION = ".zip",
+    YAML_EXTENSION = ".yml",
+    NODES_FOLDER_NAME = "nodes/",
+    SCENARIO_NODE = "SCENARIO"
+}

package/lib/interfaces/package-export-transport.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import { StudioComputeNodeDescriptor, VariableDefinition, VariablesAssignments } from "./package-manager.interfaces";
+import { SpaceTransport } from "./save-space.interface";
+export interface DependencyTransport {
+    key: string;
+    version: string;
+}
+export interface PackageExportTransport {
+    id: string;
+    key: string;
+    name: string;
+    changeDate: string;
+    activatedDraftId: string;
+    workingDraftId: string;
+    flavor: string;
+    version: string;
+    dependencies: DependencyTransport[];
+    spaceId?: string;
+    datamodels?: StudioComputeNodeDescriptor[];
+}
+export interface PackageManifestTransport {
+    packageKey: string;
+    flavor: string;
+    activeVersion: string;
+    dependenciesByVersion: Map<string, DependencyTransport[]>;
+}
+export interface VariableExportTransport {
+    key: string;
+    value: any;
+    type: string;
+    metadata: object;
+}
+export interface VariableManifestTransport {
+    packageKey: string;
+    version: string;
+    variables?: VariableExportTransport[];
+}
+export interface PackageKeyAndVersionPair {
+    packageKey: string;
+    version: string;
+}
+export interface NodeExportTransport {
+    key: string;
+    parentNodeKey: string;
+    packageNodeKey: string;
+    name: string;
+    type: string;
+    exportSerializationType: string;
+    serializedContent: string;
+    schemaVersion: number;
+    unversionedMetadata: any;
+    versionedMetdata: object;
+    invalidContent?: boolean;
+    serializedDocument: Buffer;
+}
+export interface NodeSerializedContent {
+    variables: VariableDefinition[];
+}
+export interface StudioPackageManifest {
+    packageKey: string;
+    space: Partial<SpaceTransport>;
+    runtimeVariableAssignments: VariablesAssignments[];
+}
+export interface PackageVersionImport {
+    oldVersion: string;
+    newVersion: string;
+}
+export interface PostPackageImportData {
+    packageKey: string;
+    importedVersions: PackageVersionImport[];
+}

package/lib/interfaces/package-manager.interfaces.d.ts

@@ -42,6 +42,7 @@ export interface PackageWithVariableAssignments {
     key: string;
     name: string;
     createdBy: string;
+    spaceId: string;
     variableAssignments: VariablesAssignments[];
 }
 export interface VariablesAssignments {
@@ -49,7 +50,7 @@ export interface VariablesAssignments {
     value: object;
     type: string;
 }
-export interface VariableDefinitionWithValue {
+export interface VariableDefinition {
     key: string;
     type: PackageManagerVariableType;
     description?: string;

package/lib/services/http-client-service.v2.d.ts

@@ -1,6 +1,8 @@
+import * as FormData from "form-data";
 declare class HttpClientServiceV2 {
     get(url: string): Promise<any>;
-    postFile(url: string, body: any, parameters?: {}): Promise<any>;
+    getFile(url: string): Promise<any>;
+    postFile(url: string, formData: FormData, parameters?: {}): Promise<any>;
     post(url: string, body: any): Promise<any>;
     put(url: string, body: object): Promise<any>;
     delete(url: string): Promise<any>;

package/lib/services/package-manager/batch-import-export-service.d.ts

@@ -0,0 +1,14 @@
+declare class BatchImportExportService {
+    listActivePackages(flavors: string[]): Promise<void>;
+    findAndExportListOfActivePackages(flavors: string[], packageKeys: string[], withDependencies: boolean): Promise<void>;
+    batchExportPackages(packageKeys: string[], withDependencies?: boolean): Promise<void>;
+    batchImportPackages(file: string, overwrite: boolean): Promise<void>;
+    private exportListOfPackages;
+    private getVersionsByPackageKey;
+    private getVersionedVariablesForPackagesWithKeys;
+    private buildBodyForImport;
+    private getReadableStream;
+    private parseEntryData;
+}
+export declare const batchImportExportService: BatchImportExportService;
+export {};

package/lib/services/package-manager/package-service.d.ts

@@ -5,7 +5,7 @@ declare class PackageService {
     protected readonly fileDownloadedMessage = "File downloaded successfully. New filename: ";
     listPackages(): Promise<void>;
     findAndExportListOfAllPackages(includeDependencies: boolean, packageKeys: string[]): Promise<void>;
-    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean): Promise<void>;
+    batchImportPackages(spaceMappings: string[], dataModelMappingsFilePath: string, exportedPackagesFile: string, overwrite: boolean, excludeActionFlows: boolean): Promise<void>;
     private checkNodeForCircularDependency;
     private importPackage;
     private importPackageVersion;
@@ -16,9 +16,9 @@ declare class PackageService {
     private getTargetSpaceForExportedPackage;
     private updateDependencyVersions;
     publishPackage(packageToImport: ManifestNodeTransport): Promise<void>;
-    batchExportPackages(packageKeys: string[], includeDependencies: boolean): Promise<void>;
+    batchExportPackages(packageKeys: string[], includeDependencies: boolean, excludeActionFlows?: boolean): Promise<void>;
     getNodesWithActiveVersion(nodes: BatchExportNodeTransport[]): Promise<BatchExportNodeTransport[]>;
-    getPackagesWithDependencies(draftIdByNodeId: Map<string, string>, actionFlowPackageKeys: string[]): Promise<Map<string, PackageDependencyTransport[]>>;
+    getPackagesWithDependencies(draftIdByNodeId: Map<string, string>): Promise<Map<string, PackageDependencyTransport[]>>;
     private getDependencyPackages;
     private nodeHasBeenResolvedBefore;
     private exportListOfPackages;

package/lib/services/package-manager/variable-service.d.ts

@@ -4,7 +4,13 @@ declare class VariableService {
     assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<void>;
     listCandidateAssignments(type: string, params: string): Promise<void>;
     findAndExportCandidateAssignments(type: string, params: string): Promise<void>;
+    listVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
+    exportVariables(keysByVersion: string[], keysByVersionFile: string): Promise<void>;
     private parseParams;
+    private getVersionedVariablesByKeyVersionPairs;
+    private buildKeyVersionPairs;
+    private buildKeyAndVersionPairsFromArrayInput;
+    private exportToJson;
 }
 export declare const variableService: VariableService;
 export {};