trm-core 4.1.4 → 6.0.0

package/dist/actions/publish/setCustomizingTransports.js

@@ -0,0 +1,84 @@
+"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.setCustomizingTransports = void 0;
+const logger_1 = require("../../logger");
+const inquirer_1 = require("../../inquirer");
+const transport_1 = require("../../transport");
+exports.setCustomizingTransports = {
+    name: 'set-customizing-transports',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.publishData.skipCustomizingTransports) {
+            logger_1.Logger.log(`Skipping customizing transports publish (user input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        logger_1.Logger.log('Set customizing transports step', true);
+        if (!context.rawInput.contextData.noInquirer) {
+            var defaultTransports;
+            if (Array.isArray(context.rawInput.publishData.customizingTransports)) {
+                defaultTransports = context.rawInput.publishData.customizingTransports.map(o => {
+                    return o.trkorr;
+                }).join(', ');
+            }
+            else {
+                defaultTransports = context.rawInput.publishData.customizingTransports;
+            }
+            const inq = yield inquirer_1.Inquirer.prompt({
+                message: `Add customizing transports (separated by comma)`,
+                name: 'transports',
+                type: 'input',
+                default: defaultTransports
+            });
+            context.rawInput.publishData.customizingTransports = inq.transports;
+        }
+        if (typeof (context.rawInput.publishData.customizingTransports) === 'string') {
+            context.rawInput.publishData.customizingTransports = context.rawInput.publishData.customizingTransports.split(',').map(o => {
+                if (o) {
+                    try {
+                        return new transport_1.Transport(o.trim());
+                    }
+                    catch (e) {
+                        throw new Error(`Invalid customizing transport values: trkorr.`);
+                    }
+                }
+            }).filter(o => o !== undefined);
+        }
+        var validatedTransports = [];
+        if (Array.isArray(context.rawInput.publishData.customizingTransports) && context.rawInput.publishData.customizingTransports.length > 0) {
+            logger_1.Logger.loading(`Reading customizing transports...`);
+            for (const transport of context.rawInput.publishData.customizingTransports) {
+                logger_1.Logger.log(`Checking transport ${transport.trkorr}`, true);
+                if (yield transport.getE070()) {
+                    if (!validatedTransports.find(o => o.trkorr === transport.trkorr)) {
+                        logger_1.Logger.log(`Transport ${transport.trkorr} is validated`, true);
+                        validatedTransports.push(transport);
+                    }
+                    const tasks = yield transport.getTasks();
+                    tasks.forEach(task => {
+                        if (!validatedTransports.find(o => o.trkorr === task.trkorr)) {
+                            logger_1.Logger.log(`Transport ${transport.trkorr} task is validated`, true);
+                            validatedTransports.push(task);
+                        }
+                    });
+                }
+                else {
+                    logger_1.Logger.log(`Transport ${transport.trkorr} doesn't exist`, true);
+                }
+            }
+            logger_1.Logger.info(`${context.rawInput.publishData.customizingTransports.length} customizing transports will be published.`);
+        }
+    })
+};

package/dist/actions/publish/setDevclass.js

@@ -10,33 +10,65 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDevclass = void 0;
-const Inquirer_1 = require("../../inquirer/Inquirer");
-const inquirer_1 = require("../../inquirer");
 const logger_1 = require("../../logger");
+const trmPackage_1 = require("../../trmPackage");
+const inquirer_1 = require("../../inquirer");
+const systemConnector_1 = require("../../systemConnector");
+const commons_1 = require("../../commons");
 exports.setDevclass = {
     name: 'set-devclass',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var devclass = context.parsedInput.devclass;
-        if (!devclass) {
-            if (context.parsedInput.silent) {
-                throw new Error(`Running in silent mode and devclass was not set.`);
+        logger_1.Logger.log('Set devclass step', true);
+        var needsValidation;
+        var devclass = context.rawInput.packageData.devclass;
+        if (devclass === undefined) {
+            const trmPackage = context.rawInput.contextData.systemPackages.find(o => trmPackage_1.TrmPackage.compare(o, new trmPackage_1.TrmPackage(context.rawInput.packageData.name, context.rawInput.packageData.registry)));
+            if (trmPackage) {
+                devclass = trmPackage.getDevclass();
+            }
+            if (!context.rawInput.contextData.noInquirer) {
+                devclass = (yield inquirer_1.Inquirer.prompt({
+                    type: 'input',
+                    message: 'ABAP package name',
+                    name: 'devclass',
+                    default: devclass,
+                    validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
+                        return yield (0, inquirer_1.validateDevclass)(input, false);
+                    })
+                })).devclass.trim().toUpperCase();
+                logger_1.Logger.log(`Publish devclass set to "${devclass}"`, true);
+                needsValidation = false;
             }
-            const inq1 = yield Inquirer_1.Inquirer.prompt({
-                type: "input",
-                message: "Package devclass",
-                name: "devclass",
-                validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
-                    return yield (0, inquirer_1.validateDevclass)(input);
-                })
-            });
-            devclass = inq1.devclass;
+            else {
+                needsValidation = true;
+            }
+        }
+        else {
+            needsValidation = true;
         }
-        devclass = devclass.trim().toUpperCase();
-        const devclassValid = yield (0, inquirer_1.validateDevclass)(devclass);
-        if (devclassValid && devclassValid !== true) {
-            throw new Error(devclassValid);
+        if (needsValidation) {
+            const validate = yield (0, inquirer_1.validateDevclass)(devclass, false);
+            if (validate && validate !== true) {
+                throw new Error(validate);
+            }
+            logger_1.Logger.info(`Publish ABAP package: "${devclass}"`);
+        }
+        context.rawInput.packageData.devclass = devclass;
+        logger_1.Logger.loading(`Reading "${context.rawInput.packageData.devclass}" objects...`);
+        context.runtime.packageData.tadir = yield systemConnector_1.SystemConnector.getDevclassObjects(context.rawInput.packageData.devclass, true);
+        const packageNamespace = (0, commons_1.getPackageNamespace)(context.rawInput.packageData.devclass);
+        if (packageNamespace[0] === '/') {
+            logger_1.Logger.loading(`Reading namespace ${packageNamespace}...`);
+            const namespace = yield systemConnector_1.SystemConnector.getNamespace(packageNamespace);
+            if (namespace && namespace.trnspacet && namespace.trnspacett.length > 0) {
+                context.runtime.packageData.namespace = {
+                    trnspacet: namespace.trnspacet,
+                    trnspacett: namespace.trnspacett
+                };
+            }
+            else {
+                throw new Error(`Namespace ${packageNamespace} couldn't be found on ${systemConnector_1.SystemConnector.getDest()}.`);
+            }
         }
-        logger_1.Logger.log(`Publish devclass: ${devclass}`, true);
-        context.parsedInput.devclass = devclass;
     })
 };

package/dist/actions/publish/setManifestValues.js

@@ -11,101 +11,153 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setManifestValues = void 0;
 const logger_1 = require("../../logger");
-const Inquirer_1 = require("../../inquirer/Inquirer");
+const inquirer_1 = require("../../inquirer");
+const registry_1 = require("../../registry");
+const manifest_1 = require("../../manifest");
 exports.setManifestValues = {
     name: 'set-manifest-values',
-    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.parsedInput.forceManifestInput || (!context.parsedInput.forceManifestInput && !context.runtime.packageExistsOnRegistry)) {
-            return true;
-        }
-        else {
-            logger_1.Logger.log(`Skip manifest input values step (force: ${context.parsedInput.forceManifestInput}, already exists: ${context.runtime.packageExistsOnRegistry})`, true);
-            return false;
-        }
-    }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var defaultAuthors;
-        var defaultKeywords;
-        if (context.runtime.manifest.authors) {
-            if (typeof (context.runtime.manifest.authors) === 'string') {
-                defaultAuthors = context.runtime.manifest.authors;
+        logger_1.Logger.log('Set manifest values step', true);
+        if (context.rawInput.publishData.keepLatestReleaseManifestValues) {
+            if (context.runtime.trmPackage.latestReleaseManifest) {
+                logger_1.Logger.log(`Setting manifest values like latest version (${context.runtime.trmPackage.latestReleaseManifest.version})`, true);
+                context.runtime.trmPackage.manifest = Object.assign(Object.assign({}, context.runtime.trmPackage.latestReleaseManifest), context.runtime.trmPackage.manifest);
+            }
+        }
+        if (!context.rawInput.contextData.noInquirer) {
+            var defaultAuthors;
+            var defaultKeywords;
+            if (Array.isArray(context.runtime.trmPackage.manifest.authors)) {
+                defaultAuthors = context.runtime.trmPackage.manifest.authors.map(o => {
+                    var author;
+                    if (o.name) {
+                        author = o.name;
+                        if (o.email) {
+                            author += ` <${o.email}>`;
+                        }
+                    }
+                    else if (o.email) {
+                        author = o.email;
+                    }
+                    else {
+                        throw new Error(`Invalid manifest values: authors.`);
+                    }
+                    return author;
+                }).join(', ');
+            }
+            else {
+                defaultAuthors = context.runtime.trmPackage.manifest.authors;
+            }
+            if (Array.isArray(context.runtime.trmPackage.manifest.keywords)) {
+                defaultKeywords = context.runtime.trmPackage.manifest.keywords.join(', ');
             }
             else {
-                try {
-                    defaultAuthors = context.runtime.manifest.authors.map(o => {
-                        if (o.name) {
-                            if (o.email) {
-                                return `${o.name} <${o.email}>`;
+                defaultKeywords = context.runtime.trmPackage.manifest.keywords;
+            }
+            var inq = yield inquirer_1.Inquirer.prompt([{
+                    type: "input",
+                    message: "Short description",
+                    name: "description",
+                    default: context.runtime.trmPackage.manifest.description,
+                    validate: (input) => {
+                        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
+                            if (input.length > 50) {
+                                return "Maximum length: 50 characters";
                             }
                             else {
-                                return o.name;
+                                return true;
                             }
                         }
                         else {
-                            return o.email;
+                            return true;
                         }
-                    }).filter(s => s).join(', ');
+                    }
+                }, {
+                    type: "input",
+                    message: "Website",
+                    name: "website",
+                    default: context.runtime.trmPackage.manifest.website,
+                    validate: (input) => {
+                        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
+                            if (input.length > 100) {
+                                return "Maximum length: 100 characters";
+                            }
+                            else {
+                                return true;
+                            }
+                        }
+                        else {
+                            return true;
+                        }
+                    }
+                }, {
+                    type: "input",
+                    message: "Git repository",
+                    name: "git",
+                    default: context.runtime.trmPackage.manifest.git,
+                    validate: (input) => {
+                        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC) {
+                            if (input.length > 100) {
+                                return "Maximum length: 100 characters";
+                            }
+                            else {
+                                return true;
+                            }
+                        }
+                        else {
+                            return true;
+                        }
+                    }
+                }, {
+                    type: "input",
+                    message: "Authors (separated by comma)",
+                    name: "authors",
+                    default: defaultAuthors
+                }, {
+                    type: "input",
+                    message: "Keywords (separated by comma)",
+                    name: "keywords",
+                    default: defaultKeywords
+                }, {
+                    type: "input",
+                    message: "License",
+                    name: "license",
+                    default: context.runtime.trmPackage.manifest.license
+                }]);
+            inq.authors = inq.authors.split(',').map(s => {
+                const match = s.trim().match(/^(.*?)(?:\s*<([^>]+)>)?$/);
+                if (match && match.length >= 3) {
+                    return {
+                        name: match[1] ? match[1].trim() : undefined,
+                        email: match[2] ? match[2].trim() : undefined
+                    };
                 }
-                catch (e) {
-                    defaultAuthors = '';
+                else {
+                    throw new Error(`Invalid manifest values: authors.`);
                 }
-            }
-        }
-        if (context.runtime.manifest.keywords) {
-            if (typeof (context.runtime.manifest.keywords) === 'string') {
-                defaultKeywords = context.runtime.manifest.keywords;
-            }
-            else {
-                try {
-                    defaultKeywords = context.runtime.manifest.keywords.filter(s => s).join(', ');
+            });
+            inq.keywords = inq.keywords.split(',').map(s => {
+                if (s) {
+                    return s.trim();
                 }
-                catch (e) {
-                    defaultKeywords = '';
+                else {
+                    throw new Error(`Invalid manifest values: keywords.`);
                 }
-            }
+            });
+            context.runtime.trmPackage.manifest = Object.assign(Object.assign({}, context.runtime.trmPackage.manifest), inq);
+        }
+        if (context.runtime.packageData.namespace) {
+            context.runtime.trmPackage.manifest.namespace = {
+                replicense: context.runtime.packageData.namespace.trnspacet.replicense,
+                texts: context.runtime.packageData.namespace.trnspacett.map(o => {
+                    return {
+                        description: o.descriptn,
+                        language: o.spras,
+                        owner: o.owner
+                    };
+                })
+            };
         }
-        const inq1 = yield Inquirer_1.Inquirer.prompt([{
-                type: "input",
-                message: "Package short description",
-                name: "description",
-                default: context.runtime.manifest.description,
-                when: !context.parsedInput.silent
-            }, {
-                type: "input",
-                message: "Website",
-                name: "website",
-                default: context.runtime.manifest.website,
-                when: !context.parsedInput.silent
-            }, {
-                type: "input",
-                message: "Package Git repository",
-                name: "git",
-                default: context.runtime.manifest.git,
-                when: !context.parsedInput.silent
-            }, {
-                type: "input",
-                message: "Authors (separated by comma)",
-                name: "authors",
-                when: !context.parsedInput.silent,
-                default: defaultAuthors
-            }, {
-                type: "input",
-                message: "Keywords (separated by comma)",
-                name: "keywords",
-                when: !context.parsedInput.silent,
-                default: defaultKeywords
-            }, {
-                type: "input",
-                message: "License",
-                name: "license",
-                default: context.runtime.manifest.license,
-                when: !context.parsedInput.silent
-            }]);
-        context.runtime.manifest.description = context.runtime.manifest.description || inq1.description;
-        context.runtime.manifest.website = context.runtime.manifest.website || inq1.website;
-        context.runtime.manifest.git = context.runtime.manifest.git || inq1.git;
-        context.runtime.manifest.authors = context.runtime.manifest.authors || inq1.authors;
-        context.runtime.manifest.keywords = context.runtime.manifest.keywords || inq1.keywords;
-        context.runtime.manifest.license = context.runtime.manifest.license || inq1.license;
+        context.runtime.trmPackage.manifest = manifest_1.Manifest.normalize(context.runtime.trmPackage.manifest, false);
     })
 };

package/dist/actions/publish/setReadme.js

@@ -10,13 +10,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setReadme = void 0;
-const Inquirer_1 = require("../../inquirer/Inquirer");
 const logger_1 = require("../../logger");
+const inquirer_1 = require("../../inquirer");
 exports.setReadme = {
     name: 'set-readme',
     filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        if (context.parsedInput.silent) {
-            logger_1.Logger.log(`Skipping set readme (input)`, true);
+        if (context.rawInput.publishData.readme !== undefined) {
+            logger_1.Logger.log(`Skipping readme input (user provided)`, true);
             return false;
         }
         else {
@@ -24,24 +24,23 @@ exports.setReadme = {
         }
     }),
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        const inq1 = yield Inquirer_1.Inquirer.prompt([{
-                message: 'Write readme?',
-                type: 'confirm',
-                name: 'editReadme',
-                default: false,
-                when: !context.parsedInput.skipReadme
-            }, {
-                message: 'Write readme',
-                type: 'editor',
-                name: 'readme',
-                postfix: '.md',
-                when: (hash) => {
-                    return hash.editReadme;
-                },
-                default: context.parsedInput.readme
-            }]);
-        if (inq1.readme) {
-            context.parsedInput.readme = inq1.readme;
+        logger_1.Logger.log('Set readme step', true);
+        if (!context.rawInput.contextData.noInquirer) {
+            context.rawInput.publishData.readme = (yield inquirer_1.Inquirer.prompt([{
+                    message: 'Write readme?',
+                    type: 'confirm',
+                    name: 'editReadme',
+                    default: false
+                }, {
+                    message: 'Write readme',
+                    type: 'editor',
+                    name: 'readme',
+                    postfix: '.md',
+                    when: (hash) => {
+                        return hash.editReadme;
+                    },
+                    default: `#${context.rawInput.packageData.name}`
+                }])).readme;
         }
     })
 };

package/dist/actions/publish/setTransportTarget.js

@@ -10,54 +10,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setTransportTarget = void 0;
-const Inquirer_1 = require("../../inquirer/Inquirer");
-const inquirer_1 = require("../../inquirer");
-const systemConnector_1 = require("../../systemConnector");
 const logger_1 = require("../../logger");
+const inquirer_1 = require("../../inquirer");
 exports.setTransportTarget = {
     name: 'set-transport-target',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        var trTarget = context.parsedInput.target;
-        var systemTmscsys = yield systemConnector_1.SystemConnector.getTransportTargets();
-        systemTmscsys = systemTmscsys.sort((a, b) => {
-            if (a.systyp === 'V') {
-                return -1;
-            }
-            else if (b.systyp === 'V') {
-                return 1;
+        logger_1.Logger.log('Set transport target step', true);
+        var needsValidation;
+        var transportTarget = context.rawInput.systemData.transportTarget;
+        if (transportTarget === undefined) {
+            if (!context.rawInput.contextData.noInquirer) {
+                transportTarget = (yield inquirer_1.Inquirer.prompt({
+                    type: "list",
+                    message: "Publish transport target",
+                    name: "transportTarget",
+                    validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
+                        return yield (0, inquirer_1.validateTransportTarget)(input, context.runtime.systemData.transportTargets);
+                    }),
+                    choices: context.runtime.systemData.transportTargets.map(o => {
+                        return {
+                            name: `${o.sysnam} (${o.systxt})`,
+                            value: o.sysnam
+                        };
+                    })
+                })).transportTarget;
             }
             else {
-                return 0;
+                throw new Error(`Release transport target was not declared.`);
             }
-        });
-        if (!trTarget) {
-            if (context.parsedInput.silent) {
-                throw new Error(`Running in silent mode and transport target was not set.`);
-            }
-            const inq2 = yield Inquirer_1.Inquirer.prompt({
-                type: "list",
-                message: "Transport request target",
-                name: "trTarget",
-                validate: (input) => __awaiter(void 0, void 0, void 0, function* () {
-                    return yield (0, inquirer_1.validateTransportTarget)(input, systemTmscsys);
-                }),
-                choices: systemTmscsys.map(o => {
-                    return {
-                        name: `${o.sysnam} (${o.systxt})`,
-                        value: o.sysnam
-                    };
-                })
-            });
-            trTarget = inq2.trTarget.trim().toUpperCase();
+            needsValidation = false;
         }
         else {
-            trTarget = trTarget.trim().toUpperCase();
-            const trTargetValid = yield (0, inquirer_1.validateTransportTarget)(trTarget, systemTmscsys);
-            if (trTargetValid && trTargetValid !== true) {
-                throw new Error(trTargetValid);
+            needsValidation = true;
+        }
+        if (needsValidation) {
+            const validate = yield (0, inquirer_1.validateTransportTarget)(transportTarget, context.runtime.systemData.transportTargets);
+            if (validate && validate !== true) {
+                throw new Error(validate);
             }
+            logger_1.Logger.info(`Publish transport target: "${transportTarget}"`);
         }
-        logger_1.Logger.log(`Publish target: ${trTarget}`, true);
-        context.parsedInput.trTarget = trTarget;
+        context.rawInput.systemData.transportTarget = transportTarget;
     })
 };

package/dist/client/IClient.d.ts

@@ -1,4 +1,6 @@
+import { SapMessage } from "../systemConnector";
 export interface IClient {
     open: () => Promise<void>;
     checkConnection: () => Promise<boolean>;
+    getMessage: (data: SapMessage) => Promise<string>;
 }

package/dist/{systemConnector → client}/Login.d.ts

@@ -1,6 +1,6 @@
 export type Login = {
-    client: string;
     user: string;
     passwd: string;
     lang: string;
+    client?: string;
 };

package/dist/client/RESTClient.d.ts

@@ -0,0 +1,52 @@
+import * as components from "./components";
+import * as struct from "./struct";
+import { IClient } from "./IClient";
+import { Login, SapMessage } from ".";
+export declare class RESTClient implements IClient {
+    endpoint: string;
+    rfcdest: components.RFCDEST;
+    private _login;
+    private _cLangu;
+    private _axiosInstance;
+    private _connected;
+    constructor(endpoint: string, rfcdest: components.RFCDEST, _login: Login, _cLangu: string);
+    open(): Promise<void>;
+    checkConnection(): Promise<boolean>;
+    getMessage(data: SapMessage): Promise<string>;
+    readTable(tableName: components.TABNAME, fields: struct.RFC_DB_FLD[], options?: string): Promise<any[]>;
+    getFileSystem(): Promise<struct.FILESYS>;
+    getDirTrans(): Promise<components.PFEVALUE>;
+    getBinaryFile(filePath: string): Promise<Buffer>;
+    writeBinaryFile(filePath: string, binary: Buffer): Promise<void>;
+    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>;
+    getDevclassObjects(devclass: components.DEVCLASS): Promise<struct.TADIR[]>;
+    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>;
+    addSrcTrkorr(trkorr: components.TRKORR): Promise<void>;
+    readTmsQueue(target: components.TMSSYSNAM): Promise<struct.STMSIQREQ[]>;
+    createPackage(scompkdtln: struct.SCOMPKDTLN): Promise<void>;
+    tdevcInterface(devclass: components.DEVCLASS, parentcl?: components.DEVCLASS, rmParentCl?: boolean, devlayer?: components.DEVLAYER): Promise<void>;
+    getDefaultTransportLayer(): Promise<components.DEVLAYER>;
+    tadirInterface(tadir: struct.TADIR): Promise<void>;
+    dequeueTransport(trkorr: components.TRKORR): Promise<void>;
+    forwardTransport(trkorr: components.TRKORR, target: components.TMSSYSNAM, source: components.TMSSYSNAM, importAgain?: boolean): Promise<void>;
+    importTransport(trkorr: components.TRKORR, system: components.TMSSYSNAM): Promise<void>;
+    setInstallDevc(installDevc: struct.ZTRM_INSTALLDEVC[]): Promise<void>;
+    getObjectsList(): Promise<struct.KO100[]>;
+    getTrmServerVersion(): Promise<string>;
+    trmServerPing(): Promise<string>;
+    renameTransportRequest(trkorr: components.TRKORR, as4text: components.AS4TEXT): Promise<void>;
+    setPackageIntegrity(integrity: struct.ZTRM_INTEGRITY): Promise<void>;
+    addTranslationToTr(trkorr: components.TRKORR, devclassFilter: struct.LXE_TT_PACKG_LINE[]): Promise<void>;
+    trCopy(from: components.TRKORR, to: components.TRKORR, doc?: boolean): Promise<void>;
+    getDest(): Promise<string>;
+    getTransportObjectsBulk(trkorr: components.TRKORR): Promise<struct.TADIR[]>;
+    getExistingObjectsBulk(objects: struct.TADIR[]): Promise<struct.TADIR[]>;
+    addNamespace(namespace: components.NAMESPACE, replicense: components.TRNLICENSE, texts: struct.TRNSPACETT[]): Promise<void>;
+    getR3transInfo(): Promise<string>;
+}