trm-core 6.2.5 → 6.4.0

package/dist/manifest/PostActivity.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostActivity = void 0;
+const systemConnector_1 = require("../systemConnector");
+const xml = __importStar(require("xml-js"));
+const logger_1 = require("../logger");
+class PostActivity {
+    constructor(data) {
+        this.data = data;
+        this._xml = this.getAbapXml(this.data);
+        if (!this._xml) {
+            throw new Error(`Can't parse post activity.`);
+        }
+    }
+    execute(silent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.loading(`Executing post activity: ${this.data.name}`, silent);
+            if (!PostActivity.exists(this.data.name)) {
+                throw new Error(`Class "${this.data.name}" doesn't exist.`);
+            }
+            const description = yield this.getDescription();
+            logger_1.Logger.loading(`Executing post activity: ${description}`, silent);
+            const messages = yield systemConnector_1.SystemConnector.executePostActivity(Buffer.from(this._xml, 'utf8'));
+            if (messages && messages.length > 0) {
+                for (const message of messages) {
+                    const parsedMessage = yield systemConnector_1.SystemConnector.getMessage({
+                        class: message.msgid,
+                        no: message.msgno,
+                        v1: message.msgv1,
+                        v2: message.msgv2,
+                        v3: message.msgv3,
+                        v4: message.msgv4,
+                    });
+                    logger_1.Logger.msgty(message.msgty, parsedMessage, silent);
+                }
+            }
+            else {
+                logger_1.Logger.success(`Executed post activity: ${this.getDescription()}`, silent);
+            }
+        });
+    }
+    getDescription() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._descriptions === undefined) {
+                this._descriptions = yield systemConnector_1.SystemConnector.readClassDescriptions(this.data.name);
+            }
+            if (!this._descriptions || this._descriptions.length === 0) {
+                return this.data.name || `Unknown`;
+            }
+            else {
+                if (this._descriptions.find(o => o.langu === systemConnector_1.SystemConnector.getLogonLanguage(true))) {
+                    return this._descriptions.find(o => o.langu === systemConnector_1.SystemConnector.getLogonLanguage(true)).descript;
+                }
+                else {
+                    return this._descriptions[0].descript;
+                }
+            }
+        });
+    }
+    getAbapXml(data) {
+        var oAbapXml = {
+            "_declaration": {
+                "_attributes": {
+                    "version": "1.0",
+                    "encoding": "utf-8"
+                }
+            },
+            "asx:abap": {
+                "_attributes": {
+                    "xmlns:asx": "http://www.sap.com/abapxml",
+                    "version": "1.0"
+                },
+                "asx:values": {
+                    "DATA": {
+                        "NAME": {
+                            "_text": data.name
+                        }
+                    }
+                }
+            }
+        };
+        if (Array.isArray(data.parameters)) {
+            var parameters = data.parameters.map(param => {
+                return {
+                    "NAME": {
+                        "_text": param.name
+                    },
+                    "VALUE": {
+                        "_text": param.value || ''
+                    }
+                };
+            });
+            if (parameters.length > 0) {
+                oAbapXml['asx:abap']['asx:values']['DATA']['PARAMETERS'] = {
+                    "item": parameters
+                };
+            }
+        }
+        return xml.js2xml(oAbapXml, { compact: true });
+    }
+    static exists(className) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const classObject = systemConnector_1.SystemConnector.getObject('R3TR', 'CLAS', className.trim().toUpperCase());
+            return classObject ? true : false;
+        });
+    }
+}
+exports.PostActivity = PostActivity;

package/dist/manifest/TrmManifest.d.ts

@@ -8,5 +8,6 @@ export interface TrmManifest extends TrmManifestBase {
     registry?: string;
     linkedTransport?: Transport;
     distFolder?: string;
+    srcFolder?: string;
     namespace?: TrmManifestNamespace;
 }

package/dist/manifest/TrmManifestBase.d.ts

@@ -1,5 +1,6 @@
 import { TrmManifestAuthor } from "./TrmManifestAuthor";
 import { TrmManifestDependency } from "./TrmManifestDependency";
+import { TrmManifestPostActivity } from "./TrmManifestPostActivity";
 export interface TrmManifestBase {
     backwardsCompatible?: boolean;
     description?: string;
@@ -10,4 +11,5 @@ export interface TrmManifestBase {
     keywords?: string | string[];
     dependencies?: TrmManifestDependency[];
     sapEntries?: any;
+    postActivities?: TrmManifestPostActivity[];
 }

package/dist/manifest/TrmManifestNamespace.d.ts

@@ -1,4 +1,5 @@
 export type TrmManifestNamespace = {
+    ns?: string;
     replicense: string;
     texts: {
         language: string;

package/dist/manifest/TrmManifestPostActivity.d.ts

@@ -0,0 +1,7 @@
+export type TrmManifestPostActivity = {
+    name: string;
+    parameters?: {
+        name: string;
+        value: string;
+    }[];
+};

package/dist/manifest/TrmManifestPostActivity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/manifest/index.d.ts

@@ -4,3 +4,5 @@ export * from "./TrmManifest";
 export * from "./TrmManifestAuthor";
 export * from "./TrmManifestDependency";
 export * from "./TrmManifestNamespace";
+export * from "./TrmManifestPostActivity";
+export * from "./PostActivity";

package/dist/manifest/index.js

@@ -20,3 +20,5 @@ __exportStar(require("./TrmManifest"), exports);
 __exportStar(require("./TrmManifestAuthor"), exports);
 __exportStar(require("./TrmManifestDependency"), exports);
 __exportStar(require("./TrmManifestNamespace"), exports);
+__exportStar(require("./TrmManifestPostActivity"), exports);
+__exportStar(require("./PostActivity"), exports);

package/dist/registry/AbstractRegistry.d.ts

@@ -0,0 +1,19 @@
+import { Ping, Release, View, WhoAmI } from "trm-registry-types";
+import { RegistryType } from "./RegistryType";
+import { TrmArtifact } from "../trmPackage";
+export declare abstract class AbstractRegistry {
+    endpoint: string;
+    name: string;
+    abstract compare: (registry: AbstractRegistry) => boolean;
+    getRegistryType: () => RegistryType;
+    authenticate: (defaultData: any) => Promise<AbstractRegistry>;
+    getAuthData: () => any;
+    ping: () => Promise<Ping>;
+    whoAmI: () => Promise<WhoAmI>;
+    packageExists: (name: string, version?: string) => Promise<boolean>;
+    view: (name: string, version: string) => Promise<View>;
+    getArtifact: (name: string, version: string) => Promise<TrmArtifact>;
+    publishArtifact: (packageName: string, version: string, artifact: TrmArtifact, readme?: string) => Promise<void>;
+    unpublish: (packageName: string, version: string) => Promise<void>;
+    getReleases: (packageName: string, versionRange: string) => Promise<Release[]>;
+}

package/dist/registry/AbstractRegistry.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractRegistry = void 0;
+class AbstractRegistry {
+}
+exports.AbstractRegistry = AbstractRegistry;

package/dist/registry/FileSystem.d.ts

@@ -0,0 +1,23 @@
+import { Ping, Release, View, WhoAmI } from "trm-registry-types";
+import { AbstractRegistry } from "./AbstractRegistry";
+import { RegistryType } from "./RegistryType";
+import { TrmArtifact } from "../trmPackage";
+export declare const LOCAL_RESERVED_KEYWORD = "local";
+export declare class FileSystem implements AbstractRegistry {
+    private _filePath?;
+    endpoint: string;
+    name: string;
+    constructor(_filePath?: string);
+    compare(registry: AbstractRegistry): boolean;
+    getRegistryType(): RegistryType;
+    authenticate(defaultData: any): Promise<AbstractRegistry>;
+    getAuthData(): any;
+    ping(): Promise<Ping>;
+    whoAmI(): Promise<WhoAmI>;
+    packageExists(name: string, version?: string): Promise<boolean>;
+    view(name: string, version?: string): Promise<View>;
+    getArtifact(name: string, version?: string): Promise<TrmArtifact>;
+    publishArtifact(packageName: string, version: string, artifact: TrmArtifact, readme?: string): Promise<void>;
+    unpublish(packageName: string, version: string): Promise<void>;
+    getReleases(packageName: string, versionRange: string): Promise<Release[]>;
+}

package/dist/registry/FileSystem.js

@@ -0,0 +1,161 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystem = exports.LOCAL_RESERVED_KEYWORD = void 0;
+const trm_registry_types_1 = require("trm-registry-types");
+const RegistryType_1 = require("./RegistryType");
+const trmPackage_1 = require("../trmPackage");
+const os_1 = require("os");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+exports.LOCAL_RESERVED_KEYWORD = 'local';
+class FileSystem {
+    constructor(_filePath) {
+        this._filePath = _filePath;
+        this.name = exports.LOCAL_RESERVED_KEYWORD;
+        if (this._filePath) {
+            this.endpoint = (0, path_1.parse)(this._filePath).dir;
+            this.name = (0, path_1.parse)(this._filePath).base;
+            if (this.name === this._filePath) {
+                throw new Error(`"${this._filePath}" is not a valid file path.`);
+            }
+            if (!this.endpoint) {
+                throw new Error(`Couldn't determine file directory.`);
+            }
+            if (!this.name) {
+                throw new Error(`Couldn't determine file name.`);
+            }
+            if ((0, fs_1.existsSync)(this._filePath) && (0, fs_1.lstatSync)(this._filePath).isDirectory()) {
+                throw new Error(`"${this._filePath}" is a directory. File name is missing.`);
+            }
+            if ((0, fs_1.existsSync)(this.endpoint)) {
+                if (!(0, fs_1.lstatSync)(this.endpoint).isDirectory()) {
+                    throw new Error(`"${this.endpoint}" is not a valid directory.`);
+                }
+                else {
+                    try {
+                        (0, fs_1.accessSync)(this.endpoint, fs_1.constants.W_OK);
+                    }
+                    catch (e) {
+                        throw new Error(`Cannot write to directory "${this.endpoint}".`);
+                    }
+                }
+            }
+            else {
+                (0, fs_1.mkdirSync)(this.endpoint, { recursive: true });
+            }
+        }
+    }
+    compare(registry) {
+        if (registry instanceof FileSystem) {
+            return this._filePath === registry._filePath;
+        }
+        else {
+            return false;
+        }
+    }
+    getRegistryType() {
+        return RegistryType_1.RegistryType.LOCAL;
+    }
+    authenticate(defaultData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this;
+        });
+    }
+    getAuthData() {
+        return null;
+    }
+    ping() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._filePath) {
+                return {
+                    authenticationType: trm_registry_types_1.AuthenticationType.NO_AUTH,
+                    wallMessage: {
+                        text: `File system: "${this.name}", "${this.endpoint}"`,
+                        type: trm_registry_types_1.MessageType.INFO
+                    }
+                };
+            }
+            return null;
+        });
+    }
+    whoAmI() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._filePath) {
+                return {
+                    username: (0, os_1.userInfo)().username
+                };
+            }
+            return null;
+        });
+    }
+    packageExists(name, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._filePath) {
+                return false;
+            }
+            return null;
+        });
+    }
+    view(name_1) {
+        return __awaiter(this, arguments, void 0, function* (name, version = 'latest') {
+            if (this._filePath) {
+                const userAuthorizations = {
+                    canCreateReleases: true
+                };
+                var error = new Error(`File system can't view packages!`);
+                error.response = {
+                    userAuthorizations
+                };
+                throw error;
+            }
+            return null;
+        });
+    }
+    getArtifact(name_1) {
+        return __awaiter(this, arguments, void 0, function* (name, version = 'latest') {
+            if (this._filePath) {
+                try {
+                    return new trmPackage_1.TrmArtifact((0, fs_1.readFileSync)(this._filePath));
+                }
+                catch (e) {
+                    throw new Error(`File system couldn't read package`);
+                }
+            }
+            return null;
+        });
+    }
+    publishArtifact(packageName, version, artifact, readme) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._filePath) {
+                return (0, promises_1.writeFile)(this._filePath, artifact.binary, {
+                    flag: 'w'
+                });
+            }
+            return null;
+        });
+    }
+    unpublish(packageName, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error(`File system can't delete packages!`);
+        });
+    }
+    getReleases(packageName, versionRange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._filePath) {
+                return [];
+            }
+            return null;
+        });
+    }
+}
+exports.FileSystem = FileSystem;

package/dist/registry/Registry.d.ts

@@ -1,8 +1,9 @@
 import { RegistryType } from "./RegistryType";
 import { Ping, Release, View, WhoAmI } from "trm-registry-types";
 import { TrmArtifact } from "../trmPackage/TrmArtifact";
+import { AbstractRegistry } from "./AbstractRegistry";
 export declare const PUBLIC_RESERVED_KEYWORD = "public";
-export declare class Registry {
+export declare class Registry implements AbstractRegistry {
     endpoint: string;
     name: string;
     private _registryType;
@@ -11,8 +12,9 @@ export declare class Registry {
     private _ping;
     private _whoami;
     constructor(endpoint: string, name?: string);
+    compare(registry: AbstractRegistry): boolean;
     getRegistryType(): RegistryType;
-    authenticate(defaultData?: any): Promise<Registry>;
+    authenticate(defaultData?: any): Promise<AbstractRegistry>;
     private _basicAuth;
     private _tokenAuth;
     private _oauth2;
@@ -25,5 +27,4 @@ export declare class Registry {
     publishArtifact(packageName: string, version: string, artifact: TrmArtifact, readme?: string): Promise<void>;
     unpublish(packageName: string, version: string): Promise<void>;
     getReleases(packageName: string, versionRange: string): Promise<Release[]>;
-    static compare(o1: Registry, o2: Registry): boolean;
 }

package/dist/registry/Registry.js

@@ -96,6 +96,14 @@ class Registry {
             baseURL: this.endpoint
         }, AXIOS_CTX);
     }
+    compare(registry) {
+        if (registry instanceof Registry) {
+            return this.endpoint === registry.endpoint;
+        }
+        else {
+            return false;
+        }
+    }
     getRegistryType() {
         return this._registryType;
     }
@@ -390,10 +398,5 @@ class Registry {
             return response;
         });
     }
-    static compare(o1, o2) {
-        const s1 = o1.endpoint;
-        const s2 = o2.endpoint;
-        return s1 === s2;
-    }
 }
 exports.Registry = Registry;

package/dist/registry/RegistryProvider.d.ts

@@ -0,0 +1,5 @@
+import { AbstractRegistry } from "./AbstractRegistry";
+export declare namespace RegistryProvider {
+    var registry: AbstractRegistry[];
+    function getRegistry(endpoint?: string): AbstractRegistry;
+}

package/dist/registry/RegistryProvider.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryProvider = void 0;
+const FileSystem_1 = require("./FileSystem");
+const Registry_1 = require("./Registry");
+const RegistryType_1 = require("./RegistryType");
+var RegistryProvider;
+(function (RegistryProvider) {
+    RegistryProvider.registry = [];
+    function getRegistry(endpoint) {
+        var foundRegistry;
+        if (endpoint) {
+            endpoint = endpoint.toLowerCase().trim();
+        }
+        if (!endpoint || endpoint === Registry_1.PUBLIC_RESERVED_KEYWORD) {
+            foundRegistry = RegistryProvider.registry.find(o => o.getRegistryType() === RegistryType_1.RegistryType.PUBLIC);
+            if (!foundRegistry) {
+                foundRegistry = new Registry_1.Registry(Registry_1.PUBLIC_RESERVED_KEYWORD);
+                RegistryProvider.registry.push(foundRegistry);
+            }
+        }
+        else if (endpoint === FileSystem_1.LOCAL_RESERVED_KEYWORD) {
+            foundRegistry = new FileSystem_1.FileSystem();
+        }
+        else {
+            foundRegistry = RegistryProvider.registry.find(o => o.endpoint === endpoint);
+            if (!foundRegistry) {
+                foundRegistry = new Registry_1.Registry(endpoint, endpoint);
+                RegistryProvider.registry.push(foundRegistry);
+            }
+        }
+        return foundRegistry;
+    }
+    RegistryProvider.getRegistry = getRegistry;
+})(RegistryProvider || (exports.RegistryProvider = RegistryProvider = {}));

package/dist/registry/RegistryType.d.ts

@@ -1,4 +1,5 @@
 export declare enum RegistryType {
     PUBLIC = 1,
-    PRIVATE = 2
+    PRIVATE = 2,
+    LOCAL = 3
 }

package/dist/registry/RegistryType.js

@@ -5,4 +5,5 @@ var RegistryType;
 (function (RegistryType) {
     RegistryType[RegistryType["PUBLIC"] = 1] = "PUBLIC";
     RegistryType[RegistryType["PRIVATE"] = 2] = "PRIVATE";
+    RegistryType[RegistryType["LOCAL"] = 3] = "LOCAL";
 })(RegistryType || (exports.RegistryType = RegistryType = {}));

package/dist/registry/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./Registry";
 export * from "./RegistryType";
-export * from "./RegistryType";
+export * from "./AbstractRegistry";
+export * from "./FileSystem";
+export * from "./RegistryProvider";

package/dist/registry/index.js

@@ -16,4 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Registry"), exports);
 __exportStar(require("./RegistryType"), exports);
-__exportStar(require("./RegistryType"), exports);
+__exportStar(require("./AbstractRegistry"), exports);
+__exportStar(require("./FileSystem"), exports);
+__exportStar(require("./RegistryProvider"), exports);

package/dist/systemConnector/ISystemConnector.d.ts

@@ -21,11 +21,13 @@ export interface ISystemConnector extends ISystemConnectorBase {
     createTocTransport: (text: components.AS4TEXT, target: components.TR_TARGET) => Promise<components.TRKORR>;
     createWbTransport: (text: components.AS4TEXT, target?: components.TR_TARGET) => Promise<components.TRKORR>;
     setTransportDoc: (trkorr: components.TRKORR, doc: struct.TLINE[]) => Promise<void>;
+    removeComments: (trkorr: components.TRKORR, object: components.TROBJTYPE) => Promise<void>;
     addToTransportRequest: (trkorr: components.TRKORR, content: struct.E071[], lock: boolean) => Promise<void>;
     repositoryEnvironment: (objectType: components.SEU_OBJ, objectName: components.SOBJ_NAME) => Promise<struct.SENVI[]>;
     deleteTrkorr: (trkorr: components.TRKORR) => Promise<void>;
     releaseTrkorr: (trkorr: components.TRKORR, lock: boolean, timeout?: number) => Promise<void>;
     addSkipTrkorr: (trkorr: components.TRKORR) => Promise<void>;
+    removeSkipTrkorr: (trkorr: components.TRKORR) => Promise<void>;
     addSrcTrkorr: (trkorr: components.TRKORR) => Promise<void>;
     readTmsQueue: (target: components.TMSSYSNAM) => Promise<struct.STMSIQREQ[]>;
     createPackage: (scompkdtln: struct.SCOMPKDTLN) => Promise<void>;
@@ -44,4 +46,13 @@ export interface ISystemConnector extends ISystemConnectorBase {
     getExistingObjectsBulk?: (objects: struct.TADIR[]) => Promise<struct.TADIR[]>;
     addNamespace: (namespace: components.NAMESPACE, replicense: components.TRNLICENSE, texts: struct.TRNSPACETT[]) => Promise<void>;
     getMessage: (data: SapMessage) => Promise<string>;
+    migrateTransport: (trkorr: components.TRKORR) => Promise<components.ZTRM_TRKORR>;
+    deleteTmsTransport: (trkorr: components.TRKORR, system: components.TMSSYSNAM) => Promise<void>;
+    refreshTransportTmsTxt: (trkorr: components.TRKORR) => Promise<void>;
+    getDotAbapgit: (devclass: components.DEVCLASS) => Promise<Buffer>;
+    getAbapgitSource: (devclass: components.DEVCLASS) => Promise<{
+        zip: Buffer;
+        objects: struct.TADIR[];
+    }>;
+    executePostActivity: (data: Buffer) => Promise<struct.SYMSG[]>;
 }

package/dist/systemConnector/ISystemConnectorBase.d.ts

@@ -1,4 +1,4 @@
-import { Registry } from "../registry";
+import { AbstractRegistry } from "../registry";
 import * as components from "../client/components";
 import * as struct from "../client/struct";
 import { Transport } from "../transport";
@@ -10,12 +10,12 @@ export interface ISystemConnectorBase {
     getSourceTrkorr: () => Promise<components.TRKORR[]>;
     getIgnoredTrkorr: () => Promise<components.TRKORR[]>;
     getObject: (pgmid: components.PGMID, object: components.TROBJTYPE, objName: components.SOBJ_NAME) => Promise<struct.TADIR>;
-    getInstalledPackages: (includeSoruces: boolean, refresh?: boolean) => Promise<TrmPackage[]>;
+    getInstalledPackages: (includeSoruces: boolean, refresh?: boolean, includeLocals?: boolean) => Promise<TrmPackage[]>;
     getDevclass: (devclass: components.DEVCLASS) => Promise<struct.TDEVC>;
     getTransportTargets: () => Promise<struct.TMSCSYS[]>;
     getSubpackages: (devclass: components.DEVCLASS) => Promise<struct.TDEVC[]>;
     getDevclassObjects: (devclass: components.DEVCLASS, includeSubpackages: boolean) => Promise<struct.TADIR[]>;
-    getInstallPackages: (packageName: string, registry: Registry) => Promise<InstallPackage[]>;
+    getInstallPackages: (packageName: string, registry: AbstractRegistry) => Promise<InstallPackage[]>;
     setPackageSuperpackage: (devclass: components.DEVCLASS, superpackage: components.DEVCLASS) => Promise<void>;
     clearPackageSuperpackage: (devclass: components.DEVCLASS) => Promise<void>;
     setPackageTransportLayer: (devclass: components.DEVCLASS, devlayer: components.DEVLAYER) => Promise<void>;
@@ -32,4 +32,5 @@ export interface ISystemConnectorBase {
     isTransportLayerExist: (devlayer: components.DEVLAYER) => Promise<boolean>;
     getTrmServerPackage: () => Promise<TrmPackage>;
     getTrmRestPackage: () => Promise<TrmPackage>;
+    readClassDescriptions: (clsname: components.SEOCLSNAME) => Promise<struct.SEOCLASSTX[]>;
 }

package/dist/systemConnector/RESTSystemConnector.d.ts

@@ -39,11 +39,13 @@ export declare class RESTSystemConnector extends SystemConnectorBase implements
     createTocTransport(text: components.AS4TEXT, target: components.TR_TARGET): Promise<components.TRKORR>;
     createWbTransport(text: components.AS4TEXT, target?: components.TR_TARGET): Promise<components.TRKORR>;
     setTransportDoc(trkorr: components.TRKORR, doc: struct.TLINE[]): Promise<void>;
+    removeComments(trkorr: components.TRKORR, object: components.TROBJTYPE): Promise<void>;
     addToTransportRequest(trkorr: components.TRKORR, content: struct.E071[], lock: boolean): Promise<void>;
     repositoryEnvironment(objectType: components.SEU_OBJ, objectName: components.SOBJ_NAME): Promise<struct.SENVI[]>;
     deleteTrkorr(trkorr: components.TRKORR): Promise<void>;
     releaseTrkorr(trkorr: components.TRKORR, lock: boolean, timeout?: number): Promise<void>;
     addSkipTrkorr(trkorr: components.TRKORR): Promise<void>;
+    removeSkipTrkorr(trkorr: components.TRKORR): Promise<void>;
     addSrcTrkorr(trkorr: components.TRKORR): Promise<void>;
     readTmsQueue(target: components.TMSSYSNAM): Promise<struct.STMSIQREQ[]>;
     createPackage(scompkdtln: struct.SCOMPKDTLN): Promise<void>;
@@ -62,4 +64,13 @@ export declare class RESTSystemConnector extends SystemConnectorBase implements
     getExistingObjectsBulk(objects: struct.TADIR[]): Promise<TADIR[]>;
     addNamespace(namespace: components.NAMESPACE, replicense: components.TRNLICENSE, texts: struct.TRNSPACETT[]): Promise<void>;
     getMessage(data: SapMessage): Promise<string>;
+    migrateTransport(trkorr: components.TRKORR): Promise<components.ZTRM_TRKORR>;
+    deleteTmsTransport(trkorr: components.TRKORR, system: components.TMSSYSNAM): Promise<void>;
+    refreshTransportTmsTxt(trkorr: components.TRKORR): Promise<void>;
+    getDotAbapgit(devclass: components.DEVCLASS): Promise<Buffer>;
+    getAbapgitSource(devclass: components.DEVCLASS): Promise<{
+        zip: Buffer;
+        objects: struct.TADIR[];
+    }>;
+    executePostActivity(data: Buffer): Promise<struct.SYMSG[]>;
 }