@celonis/content-cli 0.13.6 → 1.0.3

package/{services → core/utils}/file-service.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", "fs", "path", "../util/logger", "../util/yaml"], factory);
+        define(["require", "exports", "fs", "path", "./logger"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -21,8 +21,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     exports.fileService = exports.FileService = void 0;
     const fs = require("fs");
     const path = require("path");
-    const logger_1 = require("../util/logger");
-    const yaml_1 = require("../util/yaml");
+    const logger_1 = require("./logger");
     class FileService {
         writeToFileWithGivenName(data, filename) {
             fs.writeFileSync(path.resolve(process.cwd(), filename), this.getSerializedFileContent(data), {
@@ -32,10 +31,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         createDirectoryWithGivenName(dirName) {
             fs.mkdirSync(path.resolve(process.cwd(), dirName));
         }
-        readManifestFile(importedFileName) {
-            const manifest = (0, yaml_1.parse)(fs.readFileSync(path.resolve(importedFileName + "/manifest.yml"), { encoding: "utf-8" }));
-            return Promise.all(manifest);
-        }
         readFileToJson(fileName) {
             return __awaiter(this, void 0, void 0, function* () {
                 const fileContent = this.readFile(fileName);

package/core/utils/logger.js

@@ -0,0 +1,102 @@
+(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", "winston", "winston-transport", "os", "path", "fs"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.GracefulError = exports.FatalError = exports.logger = void 0;
+    const winston = require("winston");
+    const Transport = require("winston-transport");
+    const os = require("os");
+    const path = require("path");
+    const fs = require("fs");
+    class CustomTransport extends Transport {
+        constructor(opts) {
+            super(opts);
+        }
+        log(info, cb) {
+            setImmediate(() => {
+                this.emit("logged", info);
+            });
+            cb();
+            if (info.error || (info.errno && info.errno !== "__CELGRACEFULERROR")) {
+                process.exit(1);
+            }
+        }
+    }
+    // log into the same directory as where the profiles are, to avoid creating more 
+    // directories for now. Consider changing this to a general 'home' directory such 
+    // as .celonis-cli or alike.
+    const logDirName = ".celonis-content-cli-profiles";
+    const logFileName = "celonis-cli.log";
+    const exceptionLogFileName = "exceptions.log";
+    const maxLogSizeMB = 3;
+    const logDir = path.join(os.homedir(), logDirName);
+    const logFilePath = path.join(logDir, logFileName);
+    const exceptionLogFilePath = path.join(logDir, exceptionLogFileName);
+    const maxSizeBytes = maxLogSizeMB * 1024 * 1024; // 3 MB in bytes
+    // --- Ensure log directory exists ---
+    try {
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+    }
+    catch (error) {
+        console.error(`Error creating log directory: ${logDir}`, error);
+    }
+    exports.logger = winston.createLogger({
+        format: winston.format.combine(winston.format.cli()),
+        level: "debug",
+        transports: [
+            new winston.transports.Console({
+                level: "info",
+                format: winston.format.combine(winston.format.colorize()),
+            }),
+            new winston.transports.File({
+                level: "info", // Log everything from debug up to the file
+                filename: logFilePath,
+                format: winston.format.combine(winston.format.timestamp(), // Add timestamp to file logs
+                winston.format.errors({ stack: true }), // Log stack traces
+                winston.format.json() // Log in JSON format
+                ),
+                maxsize: maxSizeBytes,
+                maxFiles: 5,
+                tailable: true,
+            }),
+            new CustomTransport({})
+        ],
+        exceptionHandlers: [
+            new winston.transports.Console({
+                format: winston.format.combine(winston.format.colorize()),
+            }),
+            new winston.transports.File({
+                filename: exceptionLogFilePath, // Separate file recommended
+                format: winston.format.combine(winston.format.timestamp(), winston.format.errors({ stack: true }), winston.format.json()),
+                maxsize: maxSizeBytes,
+                maxFiles: 2, // Keep fewer exception logs if desired
+                tailable: true,
+            }),
+            new CustomTransport({})
+        ],
+        exitOnError: false,
+    });
+    // tslint:disable-next-line: max-classes-per-file
+    class FatalError extends Error {
+        constructor() {
+            super(...arguments);
+            this.error = "FatalError";
+        }
+    }
+    exports.FatalError = FatalError;
+    // By default, the logger will process.exit(1) when logging an uncaught fatal error
+    // This interface allows us to throw errors that do not force the process to exit and can be handled gracefully
+    // tslint:disable-next-line: max-classes-per-file
+    class GracefulError extends Error {
+    }
+    exports.GracefulError = GracefulError;
+});

package/{services → core/utils}/question.service.js

@@ -20,19 +20,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.QuestionService = void 0;
     const readline = require("readline");
+    /**
+     * Simple method to get input from the user/console using ReadLine. The
+     * class must be closed in order to avoid the CLI to not terminate properly.
+     */
     class QuestionService {
-        static ask(question) {
+        constructor() {
+            this.readLine = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true,
+            });
+        }
+        ask(question) {
             return __awaiter(this, void 0, void 0, function* () {
-                return new Promise((resolve, reject) => {
+                return new Promise(resolve => {
                     this.readLine.question(question, input => resolve(input));
                 });
             });
         }
+        close() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.readLine.close();
+            });
+        }
     }
     exports.QuestionService = QuestionService;
-    QuestionService.readLine = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: true,
-    });
 });

package/core/utils/version.js

@@ -0,0 +1,37 @@
+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", "fs", "find-up"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VersionUtils = void 0;
+    const fs = require("fs");
+    const findUp = require("find-up");
+    class VersionUtils {
+        static getCurrentCliVersion() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const packageJsonPath = yield findUp("package.json");
+                if (!packageJsonPath) {
+                    throw new Error("Could not find package.json");
+                }
+                const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+                return pkg.version;
+            });
+        }
+    }
+    exports.VersionUtils = VersionUtils;
+});

package/lib/{api → commands/action-flows/action-flow}/action-flow-api.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="node" />
 import * as FormData from "form-data";
-declare class ActionFlowApi {
-    static readonly INSTANCE: ActionFlowApi;
+import { Context } from "../../../core/command/cli-context";
+export declare class ActionFlowApi {
+    private httpClient;
+    constructor(context: Context);
     exportRawAssets(packageId: string): Promise<Buffer>;
     analyzeAssets(packageId: string): Promise<any>;
     importAssets(packageId: string, data: FormData, dryRun: boolean): Promise<any>;
 }
-export declare const actionFlowApi: ActionFlowApi;
-export {};

package/lib/commands/{action-flow.command.d.ts → action-flows/action-flow/action-flow-command.service.d.ts}

@@ -1,4 +1,7 @@
-export declare class ActionFlowCommand {
+import { Context } from "../../../core/command/cli-context";
+export declare class ActionFlowCommandService {
+    private actionFlowService;
+    constructor(context: Context);
     exportActionFlows(packageId: string, metadataFile: string): Promise<void>;
     analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;
     importActionFlows(packageId: string, filePath: string, dryRun: boolean, outputToJsonFile: boolean): Promise<void>;

package/lib/{services/action-flow/action-flow-service.d.ts → commands/action-flows/action-flow/action-flow.service.d.ts}

@@ -1,11 +1,11 @@
-declare class ActionFlowService {
+import { Context } from "../../../core/command/cli-context";
+export declare class ActionFlowService {
     static readonly METADATA_FILE_NAME = "metadata.json";
+    private actionFlowApi;
+    constructor(context: Context);
     exportActionFlows(packageId: string, metadataFilePath: string): Promise<void>;
     analyzeActionFlows(packageId: string, outputToJsonFile: boolean): Promise<void>;
     importActionFlows(packageId: string, filePath: string, dryRun: boolean, outputToJsonFile: boolean): Promise<void>;
     private createBodyForImport;
     private attachMetadataFile;
 }
-export declare const actionFlowService: ActionFlowService;
-export declare const metadataFileName = "metadata.json";
-export {};

package/lib/commands/action-flows/module.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Commands related to the Action Flows area.
+ */
+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 analyzeActionFlows;
+    private exportActionFlows;
+    private importActionFlows;
+    private pullSkill;
+    private pushSkill;
+}
+export = Module;

package/lib/commands/{skill.command.d.ts → action-flows/skill/skill-command.service.d.ts}

@@ -1,6 +1,7 @@
-export declare class SkillCommand {
-    private contentService;
+import { Context } from "../../../core/command/cli-context";
+export declare class SkillCommandService {
     private skillManagerFactory;
+    constructor(context: Context);
     pullSkill(profile: string, projectId: string, skillId: string): Promise<void>;
     pushSkill(profile: string, projectId: string, filename: string): Promise<void>;
 }

package/lib/commands/action-flows/skill/skill.manager-factory.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "../../../core/command/cli-context";
+import { SkillManager } from "./skill.manager";
+export declare class SkillManagerFactory {
+    private readonly context;
+    constructor(context: Context);
+    createManager(projectId: string, skillId: string, filename: string): SkillManager;
+    private readFile;
+}

package/lib/{content/manager → commands/action-flows/skill}/skill.manager.d.ts

@@ -1,10 +1,12 @@
-import { BaseManager } from "./base.manager";
-import { ManagerConfig } from "../../interfaces/manager-config.interface";
+import { Context } from "../../../core/command/cli-context";
+import { BaseManager } from "../../../core/http/http-shared/base.manager";
+import { ManagerConfig } from "../../../core/http/http-shared/manager-config.interface";
 export declare class SkillManager extends BaseManager {
     private static BASE_URL;
     private _skillId;
     private _projectId;
     private _content;
+    constructor(context: Context);
     get content(): any;
     set content(value: any);
     get skillId(): string;

package/lib/commands/analysis/analysis-bookmarks-command.service.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../core/command/cli-context";
+export declare class AnalysisBookmarksCommandService {
+    private analysisBookmarksManagerFactory;
+    constructor(context: Context);
+    pullAnalysisBookmarks(analysisId: string, type: string): Promise<void>;
+    pushAnalysisBookmarks(analysisId: string, filename: string): Promise<void>;
+}

package/lib/commands/analysis/analysis-bookmarks.manager-factory.d.ts

@@ -0,0 +1,8 @@
+import { AnalysisBookmarksManager } from "./analysis-bookmarks.manager";
+import { Context } from "../../core/command/cli-context";
+export declare class AnalysisBookmarksManagerFactory {
+    private readonly context;
+    constructor(context: Context);
+    createAnalysisBookmarksManager(filename: string, analysisId: string, type?: string): AnalysisBookmarksManager;
+    private readFile;
+}

package/lib/{content/manager → commands/analysis}/analysis-bookmarks.manager.d.ts

@@ -1,11 +1,13 @@
-import { BaseManager } from "./base.manager";
-import { ManagerConfig } from "../../interfaces/manager-config.interface";
+import { Context } from "../../core/command/cli-context";
+import { BaseManager } from "../../core/http/http-shared/base.manager";
+import { ManagerConfig } from "../../core/http/http-shared/manager-config.interface";
 export declare class AnalysisBookmarksManager extends BaseManager {
     private static BASE_URL;
     private static ANALYSIS_BOOKMARKS_FILE_PREFIX;
     private _analysisId;
     private _fileName;
     private _type;
+    constructor(context: Context);
     get fileName(): string;
     set fileName(value: string);
     get analysisId(): string;

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

@@ -0,0 +1,11 @@
+/**
+ * Commands related to the Analysis feature.
+ */
+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 pullAnalysisBookmarks;
+    private pushAnalysisBookmarks;
+}
+export = Module;

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

@@ -1,8 +1,10 @@
 /// <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;
+import { PackageExportTransport, PackageKeyAndVersionPair, PostPackageImportData, VariableManifestTransport } from "../interfaces/package-export.interfaces";
+import { Context } from "../../../core/command/cli-context";
+export declare class BatchImportExportApi {
+    private httpClient;
+    constructor(context: Context);
     findAllActivePackages(flavors: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
     findActivePackagesByVariableValue(flavors: string[], variableValue: string, variableType: string): Promise<PackageExportTransport[]>;
     findActivePackagesByKeys(packageKeys: string[], withDependencies?: boolean): Promise<PackageExportTransport[]>;
@@ -10,5 +12,3 @@ declare class BatchImportExportApi {
     importPackages(data: FormData, overwrite: boolean): Promise<PostPackageImportData[]>;
     findVariablesWithValuesByPackageKeysAndVersion(packagesByKeyAndVersion: PackageKeyAndVersionPair[]): Promise<VariableManifestTransport[]>;
 }
-export declare const batchImportExportApi: BatchImportExportApi;
-export {};

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

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

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+import { URLSearchParams } from "url";
+import { Context } from "../../../core/command/cli-context";
+export declare class VariableAssignmentCandidatesApi {
+    private httpClient;
+    constructor(context: Context);
+    getCandidateAssignments(type: string, params: URLSearchParams): Promise<object[]>;
+}

package/lib/{services/package-manager/batch-import-export-service.d.ts → commands/configuration-management/batch-import-export.service.d.ts}

@@ -1,4 +1,9 @@
-declare class BatchImportExportService {
+import { Context } from "../../core/command/cli-context";
+export declare class BatchImportExportService {
+    private batchImportExportApi;
+    private studioPackageApi;
+    private studioService;
+    constructor(context: Context);
     listActivePackages(flavors: string[]): Promise<void>;
     findAndExportListOfActivePackages(flavors: string[], packageKeys: string[], withDependencies: boolean): Promise<void>;
     batchExportPackages(packageKeys: string[], withDependencies?: boolean): Promise<void>;
@@ -12,5 +17,3 @@ declare class BatchImportExportService {
     private getReadableStream;
     private parseEntryData;
 }
-export declare const batchImportExportService: BatchImportExportService;
-export {};

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

@@ -1,4 +1,9 @@
-export declare class ConfigCommand {
+import { Context } from "../../core/command/cli-context";
+export declare class ConfigCommandService {
+    private batchImportExportService;
+    private variableService;
+    private diffService;
+    constructor(context: Context);
     listActivePackages(jsonResponse: boolean, flavors: string[], withDependencies: boolean, packageKeys: string[], variableValue: string, variableType: string): Promise<void>;
     listVariables(jsonResponse: boolean, keysByVersion: string[], keysByVersionFile: string): Promise<void>;
     batchExportPackages(packageKeys: string[], withDependencies?: boolean): Promise<void>;

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

@@ -1,4 +1,7 @@
-declare class DiffService {
+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>;
     private hasChanges;
     private diffPackagesAndReturnDiff;
@@ -9,5 +12,3 @@ declare class DiffService {
     private buildStringResponseForPackageDiffs;
     private buildStringResponseForPackageDiffMetadataList;
 }
-export declare const diffService: DiffService;
-export {};

package/lib/{interfaces/package-export-transport.d.ts → commands/configuration-management/interfaces/package-export.interfaces.d.ts}

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { StudioComputeNodeDescriptor, VariableDefinition, VariablesAssignments } from "./package-manager.interfaces";
-import { SpaceTransport } from "./save-space.interface";
+import { StudioComputeNodeDescriptor, VariableDefinition, VariablesAssignments } from "../../studio/interfaces/package-manager.interfaces";
+import { SpaceTransport } from "../../studio/interfaces/space.interface";
 export interface DependencyTransport {
     key: string;
     version: string;

package/lib/{api/variable-assignment-apis.d.ts → commands/configuration-management/interfaces/variable-assignment-apis.constants.d.ts}

@@ -1,4 +1,6 @@
-import { VariableAssignmentApi } from "../interfaces/variable-assignment-api.interface";
+export interface VariableAssignmentApi {
+    url: string;
+}
 export declare const variableAssignmentApis: {
     [key: string]: VariableAssignmentApi;
 };

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

@@ -0,0 +1,15 @@
+/**
+ * Commands related to Celonis configuration management.
+ */
+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 listActivePackages;
+    private batchExportPackages;
+    private batchImportPackages;
+    private diffPackages;
+    private listVariables;
+    private listAssignments;
+}
+export = Module;

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

@@ -1,8 +1,17 @@
-import { PackageExportTransport, StudioPackageManifest, VariableManifestTransport } from "../../interfaces/package-export-transport";
-import { ContentNodeTransport } from "../../interfaces/package-manager.interfaces";
 import { IZipEntry } from "adm-zip";
 import * as AdmZip from "adm-zip";
-declare class StudioService {
+import { PackageExportTransport, StudioPackageManifest, VariableManifestTransport } from "./interfaces/package-export.interfaces";
+import { ContentNodeTransport } from "../studio/interfaces/package-manager.interfaces";
+import { Context } from "../../core/command/cli-context";
+export declare class StudioService {
+    private studioPackageApi;
+    private studioNodeApi;
+    private studioSpaceApi;
+    private studioVariablesApi;
+    private studioDataModelService;
+    private studioSpaceService;
+    private studioVariableService;
+    constructor(context: Context);
     getExportPackagesWithStudioData(packagesToExport: PackageExportTransport[], withDependencies: boolean): Promise<PackageExportTransport[]>;
     fixConnectionVariables(variables: VariableManifestTransport[]): VariableManifestTransport[];
     getStudioPackageManifests(studioPackageKeys: string[]): Promise<StudioPackageManifest[]>;
@@ -21,5 +30,3 @@ declare class StudioService {
     private assignRuntimeVariables;
     private updateSpaceIdForNode;
 }
-export declare const studioService: StudioService;
-export {};

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

@@ -0,0 +1,6 @@
+import { Context } from "../../core/command/cli-context";
+export declare class VariableCommandService {
+    private variableService;
+    constructor(context: Context);
+    listAssignments(variableType: string, jsonResponse: boolean, params: string): Promise<void>;
+}

package/lib/{services/package-manager/variable-service.d.ts → commands/configuration-management/variable.service.d.ts}

@@ -1,16 +1,16 @@
-import { PackageManagerVariableType, PackageWithVariableAssignments, VariablesAssignments } from "../../interfaces/package-manager.interfaces";
-declare class VariableService {
-    getVariableAssignmentsForNodes(type?: PackageManagerVariableType): Promise<PackageWithVariableAssignments[]>;
-    assignVariableValues(packageKey: string, variablesAssignments: VariablesAssignments[]): Promise<void>;
+import { Context } from "../../core/command/cli-context";
+export declare class VariableService {
+    private batchImportExportApi;
+    private variableAssignmentCandidatesApi;
+    private studioService;
+    constructor(context: Context);
+    listVariables(keysByVersion: string[], keysByVersionFile: string): 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;
+    private parseParams;
 }
-export declare const variableService: VariableService;
-export {};

package/lib/commands/cpm4/ctp-command.service.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "../../core/command/cli-context";
+export declare class CTPCommandService {
+    private ctpManagerFactory;
+    constructor(context: Context);
+    pushCTPFile(filename: string, password: string, pushAnalysis: boolean, pushDataModels: boolean, existingPoolId: string, globalPoolName: string, spaceKey: string): Promise<void>;
+    private validateParamsForDataModelPush;
+}

package/lib/{content/manager → commands/cpm4}/ctp.analysis.manager.d.ts

@@ -1,6 +1,8 @@
 import { CtpManager } from "./ctp.manager";
+import { Context } from "../../core/command/cli-context";
 export declare class CtpAnalysisManager extends CtpManager {
     private static BASE_URL;
+    constructor(context: Context);
     protected getUrl(): string;
     getBody(): any;
 }

package/lib/{content/manager → commands/cpm4}/ctp.datamodel.manager.d.ts

@@ -1,9 +1,10 @@
 import { CtpManager } from "./ctp.manager";
+import { Context } from "../../core/command/cli-context";
 export declare class CtpDataModelManager extends CtpManager {
     private static BASE_URL;
     private readonly existingPoolId;
     private readonly globalPoolName;
-    constructor(existingPoolId: string, globalPoolName: string);
+    constructor(context: Context, existingPoolId: string, globalPoolName: string);
     protected getUrl(): string;
     protected getBody(): object;
 }

package/lib/{content/factory/ctp-manager.factory.d.ts → commands/cpm4/ctp.manager-factory.d.ts}

@@ -1,5 +1,8 @@
-import { CtpManager } from "../manager/ctp.manager";
+import { Context } from "../../core/command/cli-context";
+import { CtpManager } from "./ctp.manager";
 export declare class CTPManagerFactory {
+    private readonly context;
+    constructor(context: Context);
     createCtpAnalysisManager(filename: string, password: string, spaceKey: string): CtpManager;
     createCtpDataModelManager(filename: string, password: string, existingPoolId: string, globalPoolName: string): CtpManager;
     private initManager;

package/lib/{content/manager → commands/cpm4}/ctp.manager.d.ts

@@ -1,9 +1,11 @@
-import { BaseManager } from "./base.manager";
-import { ManagerConfig } from "../../interfaces/manager-config.interface";
+import { Context } from "../../core/command/cli-context";
+import { BaseManager } from "../../core/http/http-shared/base.manager";
+import { ManagerConfig } from "../../core/http/http-shared/manager-config.interface";
 export declare abstract class CtpManager extends BaseManager {
     protected _content: any;
     protected _password: string;
     protected _spaceKey?: string;
+    protected constructor(context: Context);
     get content(): any;
     set content(value: any);
     get password(): string;

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

@@ -0,0 +1,10 @@
+/**
+ * Commands related to the CPM4 area.
+ */
+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 pushCTPFile;
+}
+export = Module;

package/lib/commands/data-pipeline/connection/connection-command.service.d.ts

@@ -0,0 +1,8 @@
+import { Context } from "../../../core/command/cli-context";
+export declare class ConnectionCommandService {
+    private connectionService;
+    constructor(context: Context);
+    updateProperty(dataPoolId: string, connectionId: string, property: string, value: string): Promise<void>;
+    getProperties(dataPoolId: string, connectionId: string): Promise<void>;
+    listConnections(dataPoolId: string): Promise<any>;
+}

package/lib/commands/data-pipeline/connection/connection.commands.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Commands related to the Data Pool Connections.
+ */
+import { Configurator } from "../../../core/command/module-handler";
+import { Context } from "../../../core/command/cli-context";
+export declare class ConnectionCommands {
+    register(context: Context, configurator: Configurator): void;
+    private getCommandProperties;
+    private listConnections;
+    private updateConnectionProperty;
+}