trm-core 4.1.4 → 6.0.0

package/dist/systemConnector/RFCSystemConnector.d.ts

@@ -0,0 +1,62 @@
+import { SapMessage } from "../client";
+import { DEVCLASS } from "../client/components";
+import { TADIR } from "../client/struct";
+import { RFCConnection } from "./RFCConnection";
+import { Login } from "../client/Login";
+import { ISystemConnector } from "./ISystemConnector";
+import * as components from "../client/components";
+import * as struct from "../client/struct";
+import { SystemConnectorBase } from "./SystemConnectorBase";
+import { SystemConnectorSupportedBulk } from "./SystemConnectorSupportedBulk";
+export declare class RFCSystemConnector extends SystemConnectorBase implements ISystemConnector {
+    private _connection;
+    private _login;
+    private _traceDir?;
+    private _lang;
+    private _user;
+    private _client;
+    supportedBulk: SystemConnectorSupportedBulk;
+    constructor(_connection: RFCConnection, _login: Login, _traceDir?: string);
+    protected getSysname(): string;
+    getDest(): string;
+    protected getLangu(c: boolean): string;
+    getLogonLanguage(c?: boolean): string;
+    protected readTable(tableName: components.TABNAME, fields: struct.RFC_DB_FLD[], options?: string): Promise<any[]>;
+    protected getTrmServerVersion(): Promise<string>;
+    protected listDevclassObjects(devclass: DEVCLASS): Promise<TADIR[]>;
+    protected tdevcInterface(devclass: components.DEVCLASS, parentcl?: components.DEVCLASS, rmParentCl?: boolean, devlayer?: components.DEVLAYER): Promise<void>;
+    protected getR3transInfo(): Promise<string>;
+    getConnectionData(): RFCConnection;
+    getLogonUser(): string;
+    connect(): Promise<void>;
+    checkConnection(): Promise<boolean>;
+    ping(): Promise<string>;
+    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>;
+    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>;
+    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[]>;
+    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>;
+    addNamespace(namespace: components.NAMESPACE, replicense: components.TRNLICENSE, texts: struct.TRNSPACETT[]): Promise<void>;
+    getMessage(data: SapMessage): Promise<string>;
+}

package/dist/systemConnector/RFCSystemConnector.js

@@ -0,0 +1,246 @@
+"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.RFCSystemConnector = void 0;
+const logger_1 = require("../logger");
+const client_1 = require("../client");
+const SystemConnectorBase_1 = require("./SystemConnectorBase");
+class RFCSystemConnector extends SystemConnectorBase_1.SystemConnectorBase {
+    constructor(_connection, _login, _traceDir) {
+        super();
+        this._connection = _connection;
+        this._login = _login;
+        this._traceDir = _traceDir;
+        this.supportedBulk = {
+            getTransportObjects: false,
+            getExistingObjects: false
+        };
+        this._login.user = this._login.user.toUpperCase();
+        this._lang = this._login.lang;
+        this._user = this._login.user;
+        if (!this._connection.saprouter) {
+            delete this._connection.saprouter;
+        }
+        this._client = new client_1.RFCClient(Object.assign(Object.assign({}, this._connection), this._login), this._lang[0], this._traceDir);
+    }
+    getSysname() {
+        return this.getDest();
+    }
+    getDest() {
+        return this._connection.dest;
+    }
+    getLangu(c) {
+        return this.getLogonLanguage(c);
+    }
+    getLogonLanguage(c = false) {
+        if (c) {
+            return this._lang[0];
+        }
+        else {
+            return this._lang;
+        }
+    }
+    readTable(tableName, fields, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.readTable(tableName, fields, options);
+        });
+    }
+    getTrmServerVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getTrmServerVersion();
+        });
+    }
+    listDevclassObjects(devclass) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getDevclassObjects(devclass);
+        });
+    }
+    tdevcInterface(devclass, parentcl, rmParentCl, devlayer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.tdevcInterface(devclass, parentcl, rmParentCl, devlayer);
+        });
+    }
+    getR3transInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getR3transInfo();
+        });
+    }
+    getConnectionData() {
+        return this._connection;
+    }
+    getLogonUser() {
+        return this._user;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.Logger.loading(`Connecting to ${this.getDest()}...`);
+            try {
+                yield this._client.open();
+                logger_1.Logger.success(`Connected to ${this.getDest()} as ${this._user}.`, false);
+            }
+            catch (e) {
+                logger_1.Logger.error(`Connection to ${this.getDest()} as ${this._user} failed.`, false);
+                throw e;
+            }
+        });
+    }
+    checkConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.checkConnection();
+        });
+    }
+    ping() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._client.trmServerPing();
+        });
+    }
+    getFileSystem() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getFileSystem();
+        });
+    }
+    getDirTrans() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getDirTrans();
+        });
+    }
+    getBinaryFile(filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getBinaryFile(filePath);
+        });
+    }
+    writeBinaryFile(filePath, binary) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.writeBinaryFile(filePath, binary);
+        });
+    }
+    createTocTransport(text, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.createTocTransport(text, target);
+        });
+    }
+    createWbTransport(text, target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.createWbTransport(text, target);
+        });
+    }
+    setTransportDoc(trkorr, doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.setTransportDoc(trkorr, doc);
+        });
+    }
+    addToTransportRequest(trkorr, content, lock) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.addToTransportRequest(trkorr, content, lock);
+        });
+    }
+    repositoryEnvironment(objectType, objectName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.repositoryEnvironment(objectType, objectName);
+        });
+    }
+    deleteTrkorr(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.deleteTrkorr(trkorr);
+        });
+    }
+    releaseTrkorr(trkorr, lock, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.releaseTrkorr(trkorr, lock, timeout);
+        });
+    }
+    addSkipTrkorr(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.addSkipTrkorr(trkorr);
+        });
+    }
+    addSrcTrkorr(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.addSrcTrkorr(trkorr);
+        });
+    }
+    readTmsQueue(target) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.readTmsQueue(target);
+        });
+    }
+    createPackage(scompkdtln) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.createPackage(scompkdtln);
+        });
+    }
+    getDefaultTransportLayer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getDefaultTransportLayer();
+        });
+    }
+    tadirInterface(tadir) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.tadirInterface(tadir);
+        });
+    }
+    dequeueTransport(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.dequeueTransport(trkorr);
+        });
+    }
+    forwardTransport(trkorr, target, source, importAgain) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.forwardTransport(trkorr, target, source, importAgain);
+        });
+    }
+    importTransport(trkorr, system) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.importTransport(trkorr, system);
+        });
+    }
+    setInstallDevc(installDevc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.setInstallDevc(installDevc);
+        });
+    }
+    getObjectsList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getObjectsList();
+        });
+    }
+    renameTransportRequest(trkorr, as4text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.renameTransportRequest(trkorr, as4text);
+        });
+    }
+    setPackageIntegrity(integrity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.setPackageIntegrity(integrity);
+        });
+    }
+    addTranslationToTr(trkorr, devclassFilter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.addTranslationToTr(trkorr, devclassFilter);
+        });
+    }
+    trCopy(from, to, doc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.trCopy(from, to, doc);
+        });
+    }
+    addNamespace(namespace, replicense, texts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.addNamespace(namespace, replicense, texts);
+        });
+    }
+    getMessage(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._client.getMessage(data);
+        });
+    }
+}
+exports.RFCSystemConnector = RFCSystemConnector;

package/dist/systemConnector/SystemConnector.d.ts

@@ -1,15 +1,16 @@
-/// <reference types="node" />
 import { TRKORR, DEVCLASS, TDEVC, TMSCSYS, TADIR, PGMID, TROBJTYPE, SOBJ_NAME } from "../client";
 import { Registry } from "../registry";
 import { Transport } from "../transport";
 import { TrmPackage } from "../trmPackage";
 import { ISystemConnector } from "./ISystemConnector";
 import { InstallPackage } from "./InstallPackage";
-import { SapMessage } from "./SapMessage";
+import { SapMessage } from "../client/SapMessage";
 import * as components from "../client/components";
 import * as struct from "../client/struct";
+import { SystemConnectorSupportedBulk } from "./SystemConnectorSupportedBulk";
 export declare namespace SystemConnector {
     var systemConnector: ISystemConnector;
+    function getSupportedBulk(): SystemConnectorSupportedBulk;
     function getConnectionData(): any;
     function getDest(): string;
     function getLogonLanguage(c: boolean): string;
@@ -19,7 +20,6 @@ export declare namespace SystemConnector {
     function getTransportStatus(trkorr: TRKORR): Promise<string>;
     function getPackageWorkbenchTransport(oPackage: TrmPackage): Promise<Transport>;
     function getInstalledPackages(includeSources: boolean, refresh?: boolean): Promise<TrmPackage[]>;
-    function generateTrmServerPackage(): Promise<TrmPackage>;
     function getDevclass(devclass: DEVCLASS): Promise<TDEVC>;
     function getTransportTargets(): Promise<TMSCSYS[]>;
     function getSubpackages(devclass: DEVCLASS): Promise<TDEVC[]>;
@@ -33,6 +33,7 @@ export declare namespace SystemConnector {
     function getInstallPackages(packageName: string, registry: Registry): Promise<InstallPackage[]>;
     function setPackageSuperpackage(devclass: DEVCLASS, superpackage: DEVCLASS): Promise<void>;
     function clearPackageSuperpackage(devclass: DEVCLASS): Promise<void>;
+    function setPackageTransportLayer(devclass: DEVCLASS, devlayer: components.DEVLAYER): Promise<void>;
     function getMessage(data: SapMessage): Promise<string>;
     function checkSapEntryExists(table: string, sapEntry: any): Promise<boolean>;
     function ping(): Promise<string>;
@@ -62,4 +63,15 @@ export declare namespace SystemConnector {
     function setPackageIntegrity(integrity: struct.ZTRM_INTEGRITY): Promise<void>;
     function addTranslationToTr(trkorr: components.TRKORR, devclassFilter: struct.LXE_TT_PACKG_LINE[]): Promise<void>;
     function getFunctionModule(func: components.RS38L_FNAME): Promise<struct.TFDIR>;
+    function getTransportObjectsBulk(trkorr: components.TRKORR): Promise<struct.TADIR[]>;
+    function getExistingObjects(objects: struct.TADIR[]): Promise<struct.TADIR[]>;
+    function getExistingObjectsBulk(objects: struct.TADIR[]): Promise<struct.TADIR[]>;
+    function getNamespace(namespace: components.NAMESPACE): Promise<{
+        trnspacet: struct.TRNSPACET;
+        trnspacett: struct.TRNSPACETT[];
+    }>;
+    function addNamespace(namespace: components.NAMESPACE, replicense: components.TRNLICENSE, texts: struct.TRNSPACETT[]): Promise<void>;
+    function getR3transVersion(): Promise<string>;
+    function getR3transUnicode(): Promise<boolean>;
+    function isTransportLayerExist(devlayer: components.DEVLAYER): Promise<boolean>;
 }

package/dist/systemConnector/SystemConnector.js

@@ -26,6 +26,11 @@ var SystemConnector;
             });
         }
     }
+    function getSupportedBulk() {
+        checkSystemConnector();
+        return SystemConnector.systemConnector.supportedBulk;
+    }
+    SystemConnector.getSupportedBulk = getSupportedBulk;
     function getConnectionData() {
         checkSystemConnector();
         return SystemConnector.systemConnector.getConnectionData();
@@ -81,13 +86,6 @@ var SystemConnector;
         });
     }
     SystemConnector.getInstalledPackages = getInstalledPackages;
-    function generateTrmServerPackage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield checkSystemConnector();
-            return SystemConnector.systemConnector.generateTrmServerPackage();
-        });
-    }
-    SystemConnector.generateTrmServerPackage = generateTrmServerPackage;
     function getDevclass(devclass) {
         return __awaiter(this, void 0, void 0, function* () {
             yield checkSystemConnector();
@@ -179,6 +177,13 @@ var SystemConnector;
         });
     }
     SystemConnector.clearPackageSuperpackage = clearPackageSuperpackage;
+    function setPackageTransportLayer(devclass, devlayer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            yield SystemConnector.systemConnector.setPackageTransportLayer(devclass, devlayer);
+        });
+    }
+    SystemConnector.setPackageTransportLayer = setPackageTransportLayer;
     function getMessage(data) {
         return __awaiter(this, void 0, void 0, function* () {
             yield checkSystemConnector();
@@ -210,7 +215,7 @@ var SystemConnector;
     function readTable(tableName, fields, options) {
         return __awaiter(this, void 0, void 0, function* () {
             yield checkSystemConnector();
-            return SystemConnector.systemConnector.readTable(tableName, fields, options);
+            return SystemConnector.systemConnector['readTable'](tableName, fields, options);
         });
     }
     SystemConnector.readTable = readTable;
@@ -382,4 +387,60 @@ var SystemConnector;
         });
     }
     SystemConnector.getFunctionModule = getFunctionModule;
+    function getTransportObjectsBulk(trkorr) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.getTransportObjectsBulk(trkorr);
+        });
+    }
+    SystemConnector.getTransportObjectsBulk = getTransportObjectsBulk;
+    function getExistingObjects(objects) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.getExistingObjects(objects);
+        });
+    }
+    SystemConnector.getExistingObjects = getExistingObjects;
+    function getExistingObjectsBulk(objects) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.getExistingObjectsBulk(objects);
+        });
+    }
+    SystemConnector.getExistingObjectsBulk = getExistingObjectsBulk;
+    function getNamespace(namespace) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.getNamespace(namespace);
+        });
+    }
+    SystemConnector.getNamespace = getNamespace;
+    function addNamespace(namespace, replicense, texts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.addNamespace(namespace, replicense, texts);
+        });
+    }
+    SystemConnector.addNamespace = addNamespace;
+    function getR3transVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.getR3transVersion();
+        });
+    }
+    SystemConnector.getR3transVersion = getR3transVersion;
+    function getR3transUnicode() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.getR3transUnicode();
+        });
+    }
+    SystemConnector.getR3transUnicode = getR3transUnicode;
+    function isTransportLayerExist(devlayer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield checkSystemConnector();
+            return SystemConnector.systemConnector.isTransportLayerExist(devlayer);
+        });
+    }
+    SystemConnector.isTransportLayerExist = isTransportLayerExist;
 })(SystemConnector || (exports.SystemConnector = SystemConnector = {}));

package/dist/systemConnector/SystemConnectorBase.d.ts

@@ -0,0 +1,51 @@
+import { DEVCLASS, PGMID, SOBJ_NAME, TRKORR, TROBJTYPE } from "../client/components";
+import { TADIR, TDEVC, TMSCSYS } from "../client/struct";
+import { Transport } from "../transport";
+import { TrmPackage } from "../trmPackage";
+import { InstallPackage } from "./InstallPackage";
+import * as components from "../client/components";
+import * as struct from "../client/struct";
+import { ISystemConnectorBase } from "./ISystemConnectorBase";
+import { Registry } from "../registry";
+export declare const TRM_SERVER_PACKAGE_NAME: string;
+export declare const SRC_TRKORR_TABL = "ZTRM_SRC_TRKORR";
+export declare const SKIP_TRKORR_TABL = "ZTRM_SKIP_TRKORR";
+export declare abstract class SystemConnectorBase implements ISystemConnectorBase {
+    private _installedPackages;
+    private _installedPackagesI;
+    private _r3transInfoLog;
+    protected abstract readTable(tableName: components.TABNAME, fields: struct.RFC_DB_FLD[], options?: string): Promise<any[]>;
+    protected abstract getSysname(): string;
+    protected abstract getLangu(c: boolean): string;
+    protected abstract getTrmServerVersion(): Promise<string>;
+    protected abstract listDevclassObjects(devclass: components.DEVCLASS): Promise<struct.TADIR[]>;
+    protected abstract tdevcInterface(devclass: components.DEVCLASS, parentcl?: components.DEVCLASS, rmParentCl?: boolean, devlayer?: components.DEVLAYER): Promise<void>;
+    protected abstract getR3transInfo(): Promise<string>;
+    constructor();
+    getTransportStatus(trkorr: TRKORR): Promise<string>;
+    getPackageWorkbenchTransport(oPackage: TrmPackage): Promise<Transport>;
+    getSourceTrkorr(): Promise<TRKORR[]>;
+    getObject(pgmid: PGMID, object: TROBJTYPE, objName: SOBJ_NAME): Promise<TADIR>;
+    getIgnoredTrkorr(): Promise<TRKORR[]>;
+    private _generateTrmServerPackage;
+    getInstalledPackages(includeSoruces?: boolean, refresh?: boolean): Promise<TrmPackage[]>;
+    getDevclass(devclass: DEVCLASS): Promise<TDEVC>;
+    getTransportTargets(): Promise<TMSCSYS[]>;
+    getSubpackages(devclass: DEVCLASS): Promise<TDEVC[]>;
+    getDevclassObjects(devclass: DEVCLASS, includeSubpackages?: boolean): Promise<TADIR[]>;
+    getInstallPackages(packageName: string, registry: Registry): Promise<InstallPackage[]>;
+    setPackageSuperpackage(devclass: DEVCLASS, superpackage: DEVCLASS): Promise<void>;
+    clearPackageSuperpackage(devclass: DEVCLASS): Promise<void>;
+    setPackageTransportLayer(devclass: DEVCLASS, devlayer: components.DEVLAYER): Promise<void>;
+    checkSapEntryExists(table: string, sapEntry: any): Promise<boolean>;
+    getPackageIntegrity(oPackage: TrmPackage): Promise<string>;
+    getFunctionModule(func: string): Promise<struct.TFDIR>;
+    getExistingObjects(objects: TADIR[]): Promise<TADIR[]>;
+    getNamespace(namespace: components.NAMESPACE): Promise<{
+        trnspacet: struct.TRNSPACET;
+        trnspacett: struct.TRNSPACETT[];
+    }>;
+    getR3transVersion(): Promise<string>;
+    getR3transUnicode(): Promise<boolean>;
+    isTransportLayerExist(devlayer: components.DEVLAYER): Promise<boolean>;
+}