trm-core 9.10.6 → 10.0.1

package/dist/actions/publish/setOptionalPublishData.d.ts

@@ -0,0 +1,11 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { PublishWorkflowContext } from ".";
+/**
+ * Workflow step that collects optional readme and changelog Markdown for remote registries.
+ *
+ * 1- set readme
+ *
+ * 2- set changelog
+ *
+*/
+export declare const setOptionalReleaseData: Step<PublishWorkflowContext>;

package/dist/actions/publish/setOptionalPublishData.js

@@ -0,0 +1,133 @@
+"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.setOptionalReleaseData = void 0;
+const trm_commons_1 = require("trm-commons");
+const registry_1 = require("../../registry");
+/**
+ * Workflow step that collects optional readme and changelog Markdown for remote registries.
+ *
+ * 1- set readme
+ *
+ * 2- set changelog
+ *
+*/
+exports.setOptionalReleaseData = {
+    name: 'set-optional-release-data',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.LOCAL) {
+            trm_commons_1.Logger.log(`Skipping optional release data input (registry is local)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const readmeTemplate = `#${context.rawInput.packageData.name}`;
+        const changelogTemplate = `${context.rawInput.packageData.name} changelog
+=================
+
+Legend
+------
+\`\`\`
+* : fixed
+! : changed
++ : added
+- : removed
+\`\`\`
+
+${new Date().toISOString().split('T')[0]} v${context.rawInput.packageData.version}
+-------------------
+\`\`\`
+...
+\`\`\`
+`;
+        //1- set readme
+        if (context.rawInput.publishData.readme === undefined) {
+            if (!context.rawInput.contextData.noInquirer && trm_commons_1.Inquirer.isUi()) {
+                context.rawInput.publishData.readme = (yield trm_commons_1.Inquirer.prompt([{
+                        message: `Do you want to write a ${context.runtime.latest.data ? 'new ' : ''}readme?`,
+                        type: 'confirm',
+                        name: 'editReadme',
+                        default: false
+                    }, {
+                        message: 'Write readme',
+                        type: 'editor',
+                        name: 'readme',
+                        when: (hash) => {
+                            return hash.editReadme;
+                        },
+                        ui: {
+                            kind: 'markdown',
+                            value: readmeTemplate
+                        }
+                    }])).readme;
+            }
+            else if (!context.rawInput.contextData.noInquirer) {
+                context.rawInput.publishData.readme = (yield trm_commons_1.Inquirer.prompt([{
+                        message: `Do you want to write a ${context.runtime.latest.data ? 'new ' : ''}readme?`,
+                        type: 'confirm',
+                        name: 'editReadme',
+                        default: false
+                    }, {
+                        message: 'Write readme',
+                        type: 'editor',
+                        name: 'readme',
+                        postfix: '.md',
+                        when: (hash) => {
+                            return hash.editReadme;
+                        },
+                        default: readmeTemplate
+                    }])).readme;
+            }
+        }
+        //2- set changelog
+        if (context.rawInput.publishData.changelog === undefined) {
+            if (!context.rawInput.contextData.noInquirer && trm_commons_1.Inquirer.isUi()) {
+                context.rawInput.publishData.changelog = (yield trm_commons_1.Inquirer.prompt([{
+                        message: `Do you want to write a release changelog?`,
+                        type: 'confirm',
+                        name: 'editChangelog',
+                        default: false
+                    }, {
+                        message: 'Write changelog',
+                        type: 'editor',
+                        name: 'changelog',
+                        when: (hash) => {
+                            return hash.editChangelog;
+                        },
+                        ui: {
+                            kind: 'markdown',
+                            value: changelogTemplate
+                        }
+                    }])).changelog;
+            }
+            else if (!context.rawInput.contextData.noInquirer) {
+                context.rawInput.publishData.changelog = (yield trm_commons_1.Inquirer.prompt([{
+                        message: `Do you want to write a release changelog?`,
+                        type: 'confirm',
+                        name: 'editChangelog',
+                        default: false
+                    }, {
+                        message: 'Write changelog',
+                        type: 'editor',
+                        name: 'changelog',
+                        postfix: '.md',
+                        when: (hash) => {
+                            return hash.editChangelog;
+                        },
+                        default: changelogTemplate
+                    }])).changelog;
+            }
+        }
+    })
+};

package/dist/actions/publish/updatePackageData.d.ts

@@ -1,3 +1,11 @@
 import { Step } from "@simonegaffurini/sammarksworkflow";
 import { PublishWorkflowContext } from ".";
+/**
+ * Workflow step that records the published release in the origin system's TRM package table.
+ *
+ * Creates/update record in TRM packages table
+ *
+ * 1- commit new values
+ *
+*/
 export declare const updatePackageData: Step<PublishWorkflowContext>;

package/dist/actions/publish/updatePackageData.js

@@ -14,25 +14,38 @@ const trm_commons_1 = require("trm-commons");
 const systemConnector_1 = require("../../systemConnector");
 const crypto_1 = require("crypto");
 const registry_1 = require("../../registry");
+/**
+ * Workflow step that records the published release in the origin system's TRM package table.
+ *
+ * Creates/update record in TRM packages table
+ *
+ * 1- commit new values
+ *
+*/
 exports.updatePackageData = {
     name: 'update-package-data',
     run: (context) => __awaiter(void 0, void 0, void 0, function* () {
-        trm_commons_1.Logger.log('Update package data step', true);
+        var _a;
         try {
             trm_commons_1.Logger.loading(`Finalizing publish...`);
-            const integrity = (0, crypto_1.createHash)("sha512").update(context.runtime.trmPackage.artifact.binary).digest("base64");
+            //1- commit new values
+            //registry may have modified the artifact during publish: its integrity takes precedence
+            const integrity = (_a = context.output.trmPackage.getPublishedIntegrity()) !== null && _a !== void 0 ? _a : (0, crypto_1.createHash)("sha512").update(context.output.trmArtifact.binary).digest("base64");
             yield systemConnector_1.SystemConnector.updateTrmPackageData({
                 package_name: context.rawInput.packageData.name,
-                package_registry: context.rawInput.packageData.registry.getRegistryType() === registry_1.RegistryType.PUBLIC ? registry_1.PUBLIC_RESERVED_KEYWORD : context.rawInput.packageData.registry.endpoint,
-                manifest: Buffer.from(context.runtime.trmPackage.manifestXml, 'utf8'),
-                trkorr: context.runtime.systemData.tadirTransport.trkorr,
+                package_registry: (0, registry_1.registryKey)(context.rawInput.packageData.registry),
+                manifest: Buffer.from(context.runtime.manifestXml, 'utf8'),
+                trkorr: context.runtime.transports.tadir.trkorr,
                 integrity: integrity,
                 devclass: context.rawInput.packageData.devclass
             });
         }
         catch (e) {
-            trm_commons_1.Logger.error(`An error occurred during publish finalize. The package has been published, however TRM on ${systemConnector_1.SystemConnector.getDest()} migh be inconsistent.`);
-            trm_commons_1.Logger.error(e.toString(), true);
+            const packageName = context.rawInput.packageData.name;
+            const packageVersion = context.runtime.manifest.version;
+            trm_commons_1.Logger.error(`An error occurred during publish finalize. ${packageName} v${packageVersion} has been published, however package on ${systemConnector_1.SystemConnector.getDest()} is inconsistent.`, { important: true });
+            trm_commons_1.Logger.error(`Install ${packageName} v${packageVersion} on ${systemConnector_1.SystemConnector.getDest()} to synchronize its package data.`, { important: true });
+            trm_commons_1.Logger.error(String(e), true);
         }
     })
 };

package/dist/actions/stopWarning.d.ts

@@ -1 +1,6 @@
+/**
+ * Logs the standard warning shown before a state-changing action starts.
+ *
+ * @param action Human-readable action name included in the warning.
+ */
 export declare function stopWarning(action: string): void;

package/dist/actions/stopWarning.js

@@ -6,6 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.stopWarning = stopWarning;
 const trm_commons_1 = require("trm-commons");
 const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Logs the standard warning shown before a state-changing action starts.
+ *
+ * @param action Human-readable action name included in the warning.
+ */
 function stopWarning(action) {
     trm_commons_1.Logger.warning(`Starting ${chalk_1.default.bold(action)}!! Do not interrupt the process as it may leave inconsistencies!`);
 }

package/dist/actions/uninstall/checkDependants.d.ts

@@ -0,0 +1,7 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { UninstallWorkflowContext } from ".";
+/**
+ * Asks for confirmation before deleting a package that other installed packages depend on.
+ * Without prompts, the uninstall is aborted. Packages deleted by the same run are not dependants.
+ */
+export declare const checkDependants: Step<UninstallWorkflowContext>;

package/dist/actions/uninstall/checkDependants.js

@@ -0,0 +1,55 @@
+"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.checkDependants = void 0;
+const trm_commons_1 = require("trm-commons");
+const checkDependants_1 = require("../install/checkDependants");
+const trmPackage_1 = require("../../trmPackage");
+/**
+ * Asks for confirmation before deleting a package that other installed packages depend on.
+ * Without prompts, the uninstall is aborted. Packages deleted by the same run are not dependants.
+ */
+exports.checkDependants = {
+    name: 'check-dependants',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (context.rawInput.uninstallData.checks.noDependants) {
+            trm_commons_1.Logger.log(`Skipping check dependants (user input)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const deletedPackage = context.runtime.update;
+        // Packages deleted by the same run don't count: the ones this is installed under, and the nested ones.
+        const deleting = [...(context.uninstallingPackages || []), ...context.runtime.nestedPackages.all];
+        const dependants = (0, checkDependants_1.getDependants)(context.rawInput.contextData.systemPackages, deletedPackage)
+            .filter(dependant => !deleting.some(pkg => trmPackage_1.TrmPackage.compare(pkg, dependant.package)));
+        if (dependants.length === 0) {
+            trm_commons_1.Logger.info(`No installed packages depend on "${deletedPackage.packageName}".`, true);
+            return;
+        }
+        dependants.forEach(dependant => trm_commons_1.Logger.warning(`Dependant "${dependant.package.packageName}" requires "${deletedPackage.packageName}" ${dependant.range}.`, { important: true }));
+        let ignoreDependants = false;
+        if (!context.rawInput.contextData.noInquirer) {
+            ignoreDependants = (yield trm_commons_1.Inquirer.prompt({
+                message: `${dependants.length} installed package(s) depend on "${deletedPackage.packageName}" and might stop working. Continue with uninstall?`,
+                type: 'confirm',
+                default: false,
+                name: 'ignoreDependants'
+            })).ignoreDependants;
+        }
+        if (!ignoreDependants) {
+            throw new Error(`Uninstall aborted: installed packages depend on "${deletedPackage.packageName}".`);
+        }
+    })
+};

package/dist/actions/uninstall/forwardDeletionTransport.d.ts

@@ -0,0 +1,10 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { UninstallWorkflowContext } from ".";
+/**
+ * Workflow step that adds the deletion transport to the landscape target import queue,
+ * so the package is deleted from the following systems too.
+ *
+ * It's the same forward performed by install when upgrading a package (see `releaseLandscapeTransport`).
+ *
+*/
+export declare const forwardDeletionTransport: Step<UninstallWorkflowContext>;

package/dist/actions/uninstall/forwardDeletionTransport.js

@@ -0,0 +1,51 @@
+"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.forwardDeletionTransport = void 0;
+const trm_commons_1 = require("trm-commons");
+const transport_1 = require("../../transport");
+const utils_1 = require("../commons/utils");
+/**
+ * Workflow step that adds the deletion transport to the landscape target import queue,
+ * so the package is deleted from the following systems too.
+ *
+ * It's the same forward performed by install when upgrading a package (see `releaseLandscapeTransport`).
+ *
+*/
+exports.forwardDeletionTransport = {
+    name: 'forward-deletion-transport',
+    filter: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.rawInput.uninstallData.landscapeTransport.targetSystem) {
+            trm_commons_1.Logger.log(`Skipping forward of deletion transport (system has no transport targets)`, true);
+            return false;
+        }
+        else if (!(0, utils_1.isDeletionForwardable)(context)) {
+            trm_commons_1.Logger.log(`Skipping forward of deletion transport (package is temporary)`, true);
+            return false;
+        }
+        else {
+            return true;
+        }
+    }),
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        const targetSystem = context.rawInput.uninstallData.landscapeTransport.targetSystem;
+        yield (0, utils_1.withScopedPrefix)(`(${transport_1.Transport.getTransportIcon()}  Landscape) `, () => __awaiter(void 0, void 0, void 0, function* () {
+            trm_commons_1.Logger.loading(`Forwarding ${context.revert.dele.trkorr} to ${targetSystem}...`);
+            yield (0, utils_1.forwardDeletionTransport)(context, targetSystem);
+            context.output.targetSystem = targetSystem;
+            trm_commons_1.Logger.success(`Transport ${context.revert.dele.trkorr} added to ${targetSystem} import queue`, true);
+        }));
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, utils_1.revertForwardedDeletionTransport)(context, context.rawInput.uninstallData.landscapeTransport.targetSystem);
+        context.output.targetSystem = undefined;
+    })
+};

package/dist/actions/uninstall/generateDeletionTransport.d.ts

@@ -0,0 +1,10 @@
+import { Step } from "@simonegaffurini/sammarksworkflow";
+import { UninstallWorkflowContext } from ".";
+/**
+ * Workflow step that removes every object of the installed release through a deletion transport.
+ *
+ * It's the same cleanup performed by install when upgrading a package (see `generateUpdateTransport`),
+ * where nothing is kept because there's no incoming release.
+ *
+*/
+export declare const generateDeletionTransport: Step<UninstallWorkflowContext>;

package/dist/actions/uninstall/generateDeletionTransport.js

@@ -0,0 +1,45 @@
+"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.generateDeletionTransport = void 0;
+const stopWarning_1 = require("../stopWarning");
+const transport_1 = require("../../transport");
+const utils_1 = require("../commons/utils");
+/**
+ * Workflow step that removes every object of the installed release through a deletion transport.
+ *
+ * It's the same cleanup performed by install when upgrading a package (see `generateUpdateTransport`),
+ * where nothing is kept because there's no incoming release.
+ *
+*/
+exports.generateDeletionTransport = {
+    name: 'generate-deletion-transport',
+    run: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        if (!context.runtime.stopWarningShown) {
+            context.runtime.stopWarningShown = true;
+            (0, stopWarning_1.stopWarning)('uninstall');
+        }
+        yield (0, utils_1.cleanupInstalledPackage)(context, {
+            incomingObjects: [],
+            keptDevclasses: [],
+            prefix: `(${transport_1.Transport.getTransportIcon()}  Uninstall) `,
+            actionName: 'Uninstall',
+            requireDeletion: true
+        });
+        context.output.transport = context.runtime.dele;
+    }),
+    revert: (context) => __awaiter(void 0, void 0, void 0, function* () {
+        // Objects might still be assigned to a staging package if restoring failed:
+        // only delete staging packages after a complete restore.
+        yield (0, utils_1.revertInstalledPackageCleanup)(context);
+        yield (0, utils_1.deleteCleanupStagingPackages)(context);
+    })
+};

package/dist/actions/uninstall/index.d.ts

@@ -0,0 +1,153 @@
+import { AbstractRegistry } from "../../registry";
+import { Transport } from "../../transport";
+import { TrmPackage } from "../../trmPackage";
+import { TrmManifest } from "../../manifest";
+import { InstallTransport, TrmPackageUpdateData } from "../../systemConnector";
+import { E071 } from "../../client";
+import { IActionContext } from "../commons";
+import { ActionLockScope, PackageCleanupRevert } from "../commons/utils";
+import { InstallPackageReplacements } from "../install";
+/** Shared execution settings for the package uninstall action. */
+export type UninstallActionInputContextData = {
+    /**
+     * Snapshot of packages installed on the target system. When omitted, the action queries SAP.
+     */
+    systemPackages?: TrmPackage[];
+    /**
+     * Disable interactive prompts. Any required choice without an explicit value then causes an error.
+     */
+    noInquirer?: boolean;
+};
+/** Options controlling package uninstall validation. */
+export type UninstallActionInputUninstallData = {
+    /**
+     * Optional checks to perform before uninstalling.
+     */
+    checks?: {
+        /**
+         * Skip the check for installed packages that depend on the uninstalled package. Defaults to `false`.
+         * When the check runs and finds dependants, the uninstall requires confirmation (aborted without prompts).
+         */
+        noDependants?: boolean;
+        /**
+         * Uninstall the package even when it has changes made on the target system (dirty entries),
+         * without asking for confirmation. Defaults to `false`: dirty packages then require
+         * confirmation (aborted without prompts).
+         */
+        ignoreDirty?: boolean;
+    };
+    /**
+     * Landscape transport-related options.
+     */
+    landscapeTransport?: {
+        /**
+         * TMS target that receives the deletion transport. It is selected interactively when omitted.
+         * When omitted and the system has no transport targets, it is treated as the final system
+         * of the landscape and the deletion transport is not forwarded.
+         */
+        targetSystem?: string;
+    };
+};
+/** Input required to uninstall a TRM package from the connected SAP system. */
+export interface UninstallActionInput {
+    /** Optional shared execution settings. */
+    contextData?: UninstallActionInputContextData;
+    /**
+     * Data related to the package being uninstalled.
+     */
+    packageData: {
+        /**
+         * Name of the installed package.
+         */
+        name: string;
+        /**
+         * Registry the package was installed from. It generates the deletion transport,
+         * so it can't be a local (file system) registry.
+         */
+        registry: AbstractRegistry;
+    };
+    /** Optional validation settings. */
+    uninstallData?: UninstallActionInputUninstallData;
+}
+type WorkflowRuntime = {
+    /** Installed release being uninstalled (same role as the release replaced by an install update). */
+    update: TrmPackage;
+    previousInstallPackages: InstallPackageReplacements[];
+    /** Transports recorded for the installed release. */
+    previousInstallTransports: InstallTransport[];
+    dele?: Transport;
+    stopWarningShown: boolean;
+    /** TRM packages installed in the SAP packages of the uninstalled one; the outermost ones are uninstalled directly. */
+    nestedPackages: {
+        outermost: TrmPackage[];
+        all: TrmPackage[];
+    };
+    /** Rollbacks of the uninstalls of the TRM packages installed under this one, in execution order. */
+    nestedRollbacks: Array<() => Promise<void>>;
+    /** Lock releases of the uninstalls of the TRM packages installed under this one. */
+    nestedReleases: Array<() => Promise<void>>;
+    /** Objects removed by the deletion transports of the TRM packages installed under this one. */
+    deletedObjects?: E071[];
+};
+type WorkflowRevert = PackageCleanupRevert & {
+    metadataRemoveStarted?: boolean;
+    metadataPreviousPackageRow?: TrmPackageUpdateData;
+};
+/** Result of a successful {@link uninstall} action. */
+export type UninstallActionOutput = {
+    /** Manifest of the uninstalled release. */
+    manifest: TrmManifest;
+    /** Deletion transport imported into the connected system. */
+    transport?: Transport;
+    /** Landscape target system whose import queue received the deletion transport, when forwarded. */
+    targetSystem?: string;
+};
+/** Internal state shared by package-uninstall workflow steps and rollback handlers. */
+export interface UninstallWorkflowContext extends IActionContext {
+    lockScope?: ActionLockScope;
+    /** Original action input; optional groups are normalized during initialization. */
+    rawInput: UninstallActionInput;
+    /** Other packages uninstalled by the same run (the packages it's installed under, and their nested ones): they're not dependants. */
+    uninstallingPackages?: TrmPackage[];
+    /** Installed package and its install mappings. */
+    runtime?: WorkflowRuntime;
+    /** Data retained so completed steps can be rolled back after a later failure. */
+    revert?: WorkflowRevert;
+    /** Uninstall result assembled by the workflow. */
+    output?: UninstallActionOutput;
+}
+/**
+ * Uninstalls a TRM package from the currently connected SAP system.
+ *
+ * This is the opposite of {@link install}: the workflow authorizes the user, checks that no
+ * installed package depends on it, removes the objects of the installed release through a
+ * registry-generated deletion transport, forwards that transport to the landscape target
+ * system so the package is uninstalled there too, and removes the TRM package record. The object
+ * cleanup is the same performed when an install upgrades a package, with no incoming release.
+ * Other TRM packages installed in its SAP packages, at any depth, are uninstalled first by the same
+ * action, with the same options.
+ * Completed reversible steps are rolled back when a later step fails.
+ *
+ * This operation changes the target SAP system. Do not interrupt it while transports are being
+ * generated, imported, or released.
+ *
+ * @param inputData Package identity, registry, and uninstall options.
+ * @returns The uninstalled release manifest, the imported deletion transport, and the landscape
+ * target it was forwarded to.
+ * @throws When authorization, dependants check, deletion transport processing, or the
+ * package record removal fails.
+ */
+export declare function uninstall(inputData: UninstallActionInput): Promise<UninstallActionOutput>;
+/**
+ * Internal transactional entry point used when a parent uninstall must retain rollback ownership:
+ * the package is uninstalled, its locks stay held until `release`, and `rollback` restores it.
+ *
+ * @param uninstallingPackages Other packages uninstalled by the same run, ignored as dependants.
+ * @param parentLockScope Lock scope of the parent uninstall: its locks are taken in it and released by the parent.
+ */
+export declare function uninstallWithRollback(inputData: UninstallActionInput, uninstallingPackages: TrmPackage[], parentLockScope?: ActionLockScope): Promise<{
+    output: UninstallActionOutput;
+    rollback: () => Promise<void>;
+    release: () => Promise<void>;
+}>;
+export {};