@trustify-da/trustify-da-javascript-client 0.3.0-ea.e660b02 → 0.3.0-ea.efdc87d

package/dist/src/tools.d.ts

@@ -6,24 +6,22 @@
  */
 export function logValueFromObjects(key: string, opts?: {}, defValue: string): void;
 /**
- * Utility function will return the value for key from the environment variables,
- * if not present will return the value for key from the opts objects only if it's a string,
- * if not present, or not string will return the default value supplied which default to null.
+ * Utility function returns the value for key from opts, then environment variables,
+ * then the supplied default. Values from opts are used only if they are strings.
  * @param {string} key the key to look for in the environment variables and the opts object
  * @param {string|null} [def=null] the value to return if nothing else found
- * @param {{}} [opts={}] the options object to look for the key in if not found in environment
- * @returns {string|null} the value of the key found in the environment, options object, or the
+ * @param {{}} [opts={}] the options object to check before the environment
+ * @returns {string|null} the value of the key found in the options object, environment, or the
  * 		default supplied
  */
 export function getCustom(key: string, def?: string | null, opts?: {}): string | null;
 /**
  * Utility function for looking up custom variable for a binary path.
- * Will look in the environment variables (1) or in opts (2) for a key with TRUSTIFY_DA_x_PATH, x is an
- * uppercase version of passed name to look for. The name will also be returned if nothing else was
- * found.
+ * Looks in opts, then environment variables, for a key with TRUSTIFY_DA_x_PATH, where x is an
+ * uppercase version of the supplied name. The name is returned if neither contains the key.
  * @param name the binary name to look for, will be returned as value in nothing else found
- * @param {{}} [opts={}] the options object to look for the key in if not found in environment
- * @returns {string|null} the value of the key found in the environment, options object, or the
+ * @param {{}} [opts={}] the options object to check before the environment
+ * @returns {string|null} the value of the key found in the options object, environment, or the
  * 		original name supplied
  */
 export function getCustomPath(name: any, opts?: {}): string | null;
@@ -31,7 +29,7 @@ export function getCustomPath(name: any, opts?: {}): string | null;
  * Utility function for determining whether wrappers for build tools such as gradlew/mvnw should be
  * preferred over invoking the binary directly.
  * @param {string} name - binary for which to search for its wrapper
- * @param {{}} opts - the options object to look for the key in if not found in environment
+ * @param {{}} opts - the options object to check before the environment
  * @returns {boolean} whether to prefer the wrapper if exists or not
  */
 export function getWrapperPreference(name: string, opts?: {}): boolean;
@@ -100,13 +98,13 @@ export function invokeCommand(bin: string, args: Array<string>, opts?: import("c
  * @param {import("index.js").Options} opts - The trustify DA options that may contain proxy configuration
  * @returns {RequestInit} The fetch options with proxy agent if applicable
  */
-export function addProxyAgent(options: RequestInit, opts: import("index.js").Options): RequestInit;
+export function addProxyAgent(options: RequestInit, opts: any): RequestInit;
 /**
  * Utility function for fetching vendor tokens
  * @param {import("index.js").Options} [opts={}] - optional various options to pass along the application
  * @returns {{}}
  */
-export function getTokenHeaders(opts?: import("index.js").Options): {};
+export function getTokenHeaders(opts?: any): {};
 export const RegexNotToBeLogged: RegExp;
 export const TRUSTIFY_DA_TOKEN_HEADER: "trust-da-token";
 export const TRUSTIFY_DA_TELEMETRY_ID_HEADER: "telemetry-anonymous-id";

package/dist/src/tools.js

@@ -27,39 +27,60 @@ export function logValueFromObjects(key, opts, defValue) {
     console.log(`default value for ${key} = ${defValue} ${EOL}`);
 }
 /**
- * Utility function will return the value for key from the environment variables,
- * if not present will return the value for key from the opts objects only if it's a string,
- * if not present, or not string will return the default value supplied which default to null.
+ * Utility function returns the value for key from opts, then environment variables,
+ * then the supplied default. Values from opts are used only if they are strings.
  * @param {string} key the key to look for in the environment variables and the opts object
  * @param {string|null} [def=null] the value to return if nothing else found
- * @param {{}} [opts={}] the options object to look for the key in if not found in environment
- * @returns {string|null} the value of the key found in the environment, options object, or the
+ * @param {{}} [opts={}] the options object to check before the environment
+ * @returns {string|null} the value of the key found in the options object, environment, or the
  * 		default supplied
  */
 export function getCustom(key, def = null, opts = {}) {
     if (process.env["TRUSTIFY_DA_DEBUG"] === "true" && !key.match(RegexNotToBeLogged)) {
         logValueFromObjects(key, opts, def);
     }
-    return key in process.env ? process.env[key] : key in opts && typeof opts[key] === 'string' ? opts[key] : def;
+    return key in opts && typeof opts[key] === 'string' ? opts[key] : key in process.env ? process.env[key] : def;
+}
+/**
+ * Validates that an executable path does not use directory traversal or relative segments.
+ * @param {string} binPath - The executable path to validate.
+ * @returns {string} The validated path.
+ * @throws {Error} If the path contains '..' segments or is a relative path with separators.
+ */
+function validateExecutablePath(binPath) {
+    if (typeof binPath !== 'string' || binPath.length === 0) {
+        throw new Error('Executable path rejected: expected a non-empty string');
+    }
+    if (binPath.startsWith('./') || binPath.startsWith('.\\')) {
+        throw new Error(`Executable path rejected: relative paths starting with './' are not allowed: ${binPath}`);
+    }
+    const segments = binPath.split(/[/\\]/);
+    if (segments.includes('..')) {
+        throw new Error(`Executable path rejected: path contains directory traversal segment (..): ${binPath}`);
+    }
+    if ((binPath.includes('/') || binPath.includes('\\')) && !path.isAbsolute(binPath)) {
+        throw new Error(`Executable path rejected: relative paths are not allowed, use an absolute path or a bare command name: ${binPath}`);
+    }
+    return binPath;
 }
 /**
  * Utility function for looking up custom variable for a binary path.
- * Will look in the environment variables (1) or in opts (2) for a key with TRUSTIFY_DA_x_PATH, x is an
- * uppercase version of passed name to look for. The name will also be returned if nothing else was
- * found.
+ * Looks in opts, then environment variables, for a key with TRUSTIFY_DA_x_PATH, where x is an
+ * uppercase version of the supplied name. The name is returned if neither contains the key.
  * @param name the binary name to look for, will be returned as value in nothing else found
- * @param {{}} [opts={}] the options object to look for the key in if not found in environment
- * @returns {string|null} the value of the key found in the environment, options object, or the
+ * @param {{}} [opts={}] the options object to check before the environment
+ * @returns {string|null} the value of the key found in the options object, environment, or the
  * 		original name supplied
  */
 export function getCustomPath(name, opts = {}) {
-    return getCustom(`TRUSTIFY_DA_${name.toUpperCase()}_PATH`, name, opts);
+    const resolvedPath = getCustom(`TRUSTIFY_DA_${name.toUpperCase()}_PATH`, name, opts);
+    return validateExecutablePath(resolvedPath);
 }
 /**
  * Utility function for determining whether wrappers for build tools such as gradlew/mvnw should be
  * preferred over invoking the binary directly.
  * @param {string} name - binary for which to search for its wrapper
- * @param {{}} opts - the options object to look for the key in if not found in environment
+ * @param {{}} opts - the options object to check before the environment
  * @returns {boolean} whether to prefer the wrapper if exists or not
  */
 export function getWrapperPreference(name, opts = {}) {

package/dist/src/updaters/maven_updater.d.ts

@@ -0,0 +1,58 @@
+/**
+ * One entry in {@link updateMavenVersions}' `applied` list: a version that was changed and
+ * where. `type` discriminates the edit site — `'direct'` for a dependency's own `<version>`,
+ * `'property'` for a `${property}` reference (then `property` names the resolved property).
+ * @typedef {{
+ *   groupId: string,
+ *   artifactId: string,
+ *   newVersion: string,
+ *   type: ('direct'|'property'),
+ *   property?: string
+ * }} MavenAppliedChange
+ */
+/**
+ * Stable edit-site key for a Maven change: same key => same commit/PR. Deps whose versions
+ * resolve to one `${property}` share the property key and are therefore inseparable.
+ * @param {string} manifestPath
+ * @param {MavenAppliedChange} applied
+ * @returns {string}
+ */
+export function mavenChangeKey(manifestPath: string, applied: MavenAppliedChange): string;
+/**
+ * Updates dependency versions in a Maven pom.xml while preserving file formatting.
+ *
+ * Uses `fast-xml-parser` to understand the XML structure (dependencies and properties),
+ * then performs position-based string splice to replace version strings without altering
+ * any other formatting, comments, whitespace, or indentation.
+ *
+ * Supports `${property}` indirection: when a dependency's `<version>` is a property
+ * reference, the updater resolves the property chain (including recursive references)
+ * and updates the terminal property value in `<properties>` instead.
+ *
+ * @param {string} pomContent - the raw pom.xml file content
+ * @param {import('../remediate.js').VersionChangeRequest[]} versionChanges - list of version changes to apply
+ * @returns {{content: string, applied: MavenAppliedChange[], skipped: Array<{groupId: string, artifactId: string, newVersion: string, reason: string}>}} the updated content and
+ *   lists of applied and skipped changes
+ */
+export function updateMavenVersions(pomContent: string, versionChanges: import("../remediate.js").VersionChangeRequest[]): {
+    content: string;
+    applied: MavenAppliedChange[];
+    skipped: Array<{
+        groupId: string;
+        artifactId: string;
+        newVersion: string;
+        reason: string;
+    }>;
+};
+/**
+ * One entry in {@link updateMavenVersions}' `applied` list: a version that was changed and
+ * where. `type` discriminates the edit site — `'direct'` for a dependency's own `<version>`,
+ * `'property'` for a `${property}` reference (then `property` names the resolved property).
+ */
+export type MavenAppliedChange = {
+    groupId: string;
+    artifactId: string;
+    newVersion: string;
+    type: ("direct" | "property");
+    property?: string;
+};

package/dist/src/updaters/maven_updater.js

@@ -0,0 +1,345 @@
+import { XMLParser } from 'fast-xml-parser';
+/**
+ * Extracts the trimmed text content of a simple XML element from a string block.
+ * @param {string} block - the XML text to search within
+ * @param {string} tagName - the element name whose content to extract
+ * @returns {string|null} the trimmed text content, or null if not found
+ */
+function extractTagContent(block, tagName) {
+    const openTag = `<${tagName}>`;
+    const closeTag = `</${tagName}>`;
+    const start = block.indexOf(openTag);
+    if (start === -1) {
+        return null;
+    }
+    const contentStart = start + openTag.length;
+    const end = block.indexOf(closeTag, contentStart);
+    if (end === -1) {
+        return null;
+    }
+    return block.substring(contentStart, end).trim();
+}
+/**
+ * Finds the character positions of an XML element's text content within the raw file.
+ * Returns the start (inclusive) and end (exclusive) offsets of the text between the
+ * opening and closing tags.
+ * @param {string} content - full raw XML content
+ * @param {number} searchStart - start offset to search from
+ * @param {number} searchEnd - end offset to search within
+ * @param {string} tagName - the element name whose content position to locate
+ * @returns {{start: number, end: number}|null} character offsets, or null if not found
+ */
+function findTagContentPosition(content, searchStart, searchEnd, tagName) {
+    const openTag = `<${tagName}>`;
+    const closeTag = `</${tagName}>`;
+    const tagStart = content.indexOf(openTag, searchStart);
+    if (tagStart === -1 || tagStart >= searchEnd) {
+        return null;
+    }
+    const contentStart = tagStart + openTag.length;
+    const tagEnd = content.indexOf(closeTag, contentStart);
+    if (tagEnd === -1 || tagEnd > searchEnd) {
+        return null;
+    }
+    return { start: contentStart, end: tagEnd };
+}
+/**
+ * Checks whether the character immediately following a tag prefix indicates
+ * that the prefix is the complete tag name (e.g. `<dependency>` vs `<dependencyManagement>`).
+ * @param {string} char - the character after the tag prefix
+ * @returns {boolean} true if the character terminates the tag name
+ */
+function isTagBoundary(char) {
+    return char === '>' || char === ' ' || char === '\t'
+        || char === '\n' || char === '\r' || char === '/';
+}
+/**
+ * Finds the text content position of a `<version>` element within the first
+ * `<dependency>` block matching the given groupId and artifactId.
+ * Searches through all `<dependency>` elements in the file, covering both
+ * `<dependencies>` and `<dependencyManagement>` sections.
+ * @param {string} content - full raw pom.xml content
+ * @param {string} groupId - the dependency's groupId to match
+ * @param {string} artifactId - the dependency's artifactId to match
+ * @returns {{start: number, end: number}|null} version content offsets, or null
+ */
+function findDependencyVersionPosition(content, groupId, artifactId) {
+    let searchStart = 0;
+    const TAG_PREFIX = '<dependency';
+    const CLOSE_TAG = '</dependency>';
+    while (searchStart < content.length) {
+        const start = content.indexOf(TAG_PREFIX, searchStart);
+        if (start === -1) {
+            break;
+        }
+        // Verify this is exactly <dependency> and not <dependencyManagement> etc.
+        const charAfterTag = content.charAt(start + TAG_PREFIX.length);
+        if (!isTagBoundary(charAfterTag)) {
+            searchStart = start + 1;
+            continue;
+        }
+        // Find closing </dependency>
+        const end = content.indexOf(CLOSE_TAG, start + TAG_PREFIX.length);
+        if (end === -1) {
+            break;
+        }
+        const blockEnd = end + CLOSE_TAG.length;
+        const block = content.substring(start, blockEnd);
+        const gid = extractTagContent(block, 'groupId');
+        const aid = extractTagContent(block, 'artifactId');
+        if (gid === groupId && aid === artifactId) {
+            const pos = findTagContentPosition(content, start, blockEnd, 'version');
+            if (pos) {
+                return pos;
+            }
+            // Matching dependency but no <version> element; continue searching
+            // (the version may be in <dependencyManagement>)
+        }
+        searchStart = blockEnd;
+    }
+    return null;
+}
+/**
+ * Finds the text content position of a property element inside a `<properties>` block.
+ * Searches through all `<properties>` blocks in the file.
+ * @param {string} content - full raw pom.xml content
+ * @param {string} propName - the property element name to locate
+ * @returns {{start: number, end: number}|null} property value offsets, or null
+ */
+function findPropertyPosition(content, propName) {
+    let searchStart = 0;
+    const TAG_PREFIX = '<properties';
+    const CLOSE_TAG = '</properties>';
+    while (searchStart < content.length) {
+        const propsStart = content.indexOf(TAG_PREFIX, searchStart);
+        if (propsStart === -1) {
+            break;
+        }
+        // Verify this is exactly <properties> and not some other tag
+        const charAfter = content.charAt(propsStart + TAG_PREFIX.length);
+        if (!isTagBoundary(charAfter)) {
+            searchStart = propsStart + 1;
+            continue;
+        }
+        const propsCloseStart = content.indexOf(CLOSE_TAG, propsStart);
+        if (propsCloseStart === -1) {
+            break;
+        }
+        const propsBlockEnd = propsCloseStart + CLOSE_TAG.length;
+        const result = findTagContentPosition(content, propsStart, propsBlockEnd, propName);
+        if (result) {
+            return result;
+        }
+        searchStart = propsBlockEnd;
+    }
+    return null;
+}
+/**
+ * Resolves a Maven property chain, following `${propName}` references through
+ * the properties map until a concrete (non-reference) value is reached.
+ * Detects circular references via a visited set.
+ * @param {string} propName - the initial property name to resolve
+ * @param {Object} properties - properties map from the parsed XML
+ * @param {Set<string>} [visited] - visited property names (for cycle detection)
+ * @returns {{terminalPropName: string, resolvedValue: string}|{error: string}}
+ */
+function resolvePropertyChain(propName, properties, visited = new Set()) {
+    if (visited.has(propName)) {
+        const chain = [...visited, propName].join(' -> ');
+        return { error: `Circular property reference detected: ${chain}` };
+    }
+    visited.add(propName);
+    const value = properties[propName];
+    if (value == null) {
+        return { error: `Property '${propName}' not found in <properties>` };
+    }
+    const valueStr = String(value);
+    const propMatch = valueStr.match(/^\$\{(.+)\}$/);
+    if (propMatch) {
+        return resolvePropertyChain(propMatch[1], properties, visited);
+    }
+    return { terminalPropName: propName, resolvedValue: valueStr };
+}
+/**
+ * One entry in {@link updateMavenVersions}' `applied` list: a version that was changed and
+ * where. `type` discriminates the edit site — `'direct'` for a dependency's own `<version>`,
+ * `'property'` for a `${property}` reference (then `property` names the resolved property).
+ * @typedef {{
+ *   groupId: string,
+ *   artifactId: string,
+ *   newVersion: string,
+ *   type: ('direct'|'property'),
+ *   property?: string
+ * }} MavenAppliedChange
+ */
+/**
+ * Stable edit-site key for a Maven change: same key => same commit/PR. Deps whose versions
+ * resolve to one `${property}` share the property key and are therefore inseparable.
+ * @param {string} manifestPath
+ * @param {MavenAppliedChange} applied
+ * @returns {string}
+ */
+export function mavenChangeKey(manifestPath, applied) {
+    return applied.type === 'property'
+        ? `mvn:prop:${manifestPath}:${applied.property}`
+        : `mvn:direct:${manifestPath}:${applied.groupId}:${applied.artifactId}`;
+}
+/**
+ * Updates dependency versions in a Maven pom.xml while preserving file formatting.
+ *
+ * Uses `fast-xml-parser` to understand the XML structure (dependencies and properties),
+ * then performs position-based string splice to replace version strings without altering
+ * any other formatting, comments, whitespace, or indentation.
+ *
+ * Supports `${property}` indirection: when a dependency's `<version>` is a property
+ * reference, the updater resolves the property chain (including recursive references)
+ * and updates the terminal property value in `<properties>` instead.
+ *
+ * @param {string} pomContent - the raw pom.xml file content
+ * @param {import('../remediate.js').VersionChangeRequest[]} versionChanges - list of version changes to apply
+ * @returns {{content: string, applied: MavenAppliedChange[], skipped: Array<{groupId: string, artifactId: string, newVersion: string, reason: string}>}} the updated content and
+ *   lists of applied and skipped changes
+ */
+export function updateMavenVersions(pomContent, versionChanges) {
+    if (!versionChanges || versionChanges.length === 0) {
+        return { content: pomContent, applied: [], skipped: [] };
+    }
+    const parser = new XMLParser({
+        parseTagValue: false,
+        commentPropName: '#comment',
+    });
+    let parsed;
+    try {
+        parsed = parser.parse(pomContent);
+    }
+    catch (e) {
+        return {
+            content: pomContent,
+            applied: [],
+            skipped: versionChanges.map(vc => ({
+                groupId: vc.groupId,
+                artifactId: vc.artifactId,
+                newVersion: vc.newVersion,
+                reason: `Failed to parse pom.xml: ${e.message}`,
+            })),
+        };
+    }
+    const project = parsed?.project;
+    if (!project) {
+        return {
+            content: pomContent,
+            applied: [],
+            skipped: versionChanges.map(vc => ({
+                groupId: vc.groupId,
+                artifactId: vc.artifactId,
+                newVersion: vc.newVersion,
+                reason: 'No <project> element found in pom.xml',
+            })),
+        };
+    }
+    const properties = project.properties || {};
+    const applied = [];
+    const skipped = [];
+    /** @type {Map<number, {start: number, end: number, newValue: string}>} */
+    const replacementsByPosition = new Map();
+    for (const change of versionChanges) {
+        const versionPos = findDependencyVersionPosition(pomContent, change.groupId, change.artifactId);
+        if (!versionPos) {
+            skipped.push({
+                groupId: change.groupId,
+                artifactId: change.artifactId,
+                newVersion: change.newVersion,
+                reason: 'Dependency not found in pom.xml or has no <version> element',
+            });
+            continue;
+        }
+        const currentVersion = pomContent.substring(versionPos.start, versionPos.end);
+        const propMatch = currentVersion.match(/^\$\{(.+)\}$/);
+        if (propMatch) {
+            const resolved = resolvePropertyChain(propMatch[1], properties);
+            if (resolved.error) {
+                skipped.push({
+                    groupId: change.groupId,
+                    artifactId: change.artifactId,
+                    newVersion: change.newVersion,
+                    reason: resolved.error,
+                });
+                continue;
+            }
+            const propPos = findPropertyPosition(pomContent, resolved.terminalPropName);
+            if (!propPos) {
+                skipped.push({
+                    groupId: change.groupId,
+                    artifactId: change.artifactId,
+                    newVersion: change.newVersion,
+                    reason: `Could not locate property '${resolved.terminalPropName}' in pom.xml`,
+                });
+                continue;
+            }
+            // Deduplicate: multiple deps may share the same property
+            const existing = replacementsByPosition.get(propPos.start);
+            if (existing) {
+                if (existing.newValue !== change.newVersion) {
+                    skipped.push({
+                        groupId: change.groupId,
+                        artifactId: change.artifactId,
+                        newVersion: change.newVersion,
+                        reason: `Property '${resolved.terminalPropName}' already targeted `
+                            + `with a different version '${existing.newValue}'`,
+                    });
+                    continue;
+                }
+                // Same replacement already queued; record as applied without duplicating
+            }
+            else {
+                replacementsByPosition.set(propPos.start, {
+                    start: propPos.start,
+                    end: propPos.end,
+                    newValue: change.newVersion,
+                });
+            }
+            applied.push({
+                groupId: change.groupId,
+                artifactId: change.artifactId,
+                newVersion: change.newVersion,
+                type: 'property',
+                property: resolved.terminalPropName,
+            });
+        }
+        else {
+            const existing = replacementsByPosition.get(versionPos.start);
+            if (existing) {
+                if (existing.newValue !== change.newVersion) {
+                    skipped.push({
+                        groupId: change.groupId,
+                        artifactId: change.artifactId,
+                        newVersion: change.newVersion,
+                        reason: `Version already targeted with a different version '${existing.newValue}'`,
+                    });
+                    continue;
+                }
+            }
+            else {
+                replacementsByPosition.set(versionPos.start, {
+                    start: versionPos.start,
+                    end: versionPos.end,
+                    newValue: change.newVersion,
+                });
+            }
+            applied.push({
+                groupId: change.groupId,
+                artifactId: change.artifactId,
+                newVersion: change.newVersion,
+                type: 'direct',
+            });
+        }
+    }
+    // Sort replacements by position descending to preserve offsets during splice
+    const sortedReplacements = [...replacementsByPosition.values()]
+        .sort((a, b) => b.start - a.start);
+    let result = pomContent;
+    for (const r of sortedReplacements) {
+        result = result.substring(0, r.start) + r.newValue + result.substring(r.end);
+    }
+    return { content: result, applied, skipped };
+}

package/dist/src/updaters/toml_updater.d.ts

@@ -0,0 +1,62 @@
+/**
+ * One entry in {@link updateTomlVersions}' `applied` list: a version that was changed and where.
+ * `type` discriminates the edit site — `'ref'` for a `[libraries]` entry pointing at a shared
+ * `[versions]` alias via `version.ref` (then `versionRef` names that alias), `'inline'` for a
+ * version declared directly on the library. `alias` is the library's catalog key in both cases.
+ * @typedef {{
+ *   groupId: string,
+ *   artifactId: string,
+ *   newVersion: string,
+ *   oldVersion: string,
+ *   type: ('ref'|'inline'),
+ *   alias: string,
+ *   versionRef?: string
+ * }} TomlAppliedChange
+ */
+/**
+ * Stable edit-site key for a TOML (Gradle version catalog) change: same key => same commit/PR.
+ * Deps sharing one `[versions]` alias via `version.ref` share the ref key and are inseparable.
+ * @param {string} manifestPath
+ * @param {TomlAppliedChange} applied
+ * @returns {string}
+ */
+export function tomlChangeKey(manifestPath: string, applied: TomlAppliedChange): string;
+/**
+ * Updates dependency versions in a Gradle version catalog (libs.versions.toml) file.
+ *
+ * Supports two version declaration patterns:
+ * - Centralized: [versions] section defines version aliases, [libraries] references via version.ref
+ * - Inline: [libraries] entries include version = "x.y.z" directly
+ *
+ * Uses smol-toml parse() to locate keys, then performs position-based string replacement
+ * on the raw content to preserve formatting and comments.
+ *
+ * @param {string} tomlContent - raw TOML file content
+ * @param {import('../remediate.js').VersionChangeRequest[]} versionChanges
+ * @returns {{content: string, applied: TomlAppliedChange[], skipped: Array<{groupId: string, artifactId: string, newVersion: string, reason: string}>}}
+ */
+export function updateTomlVersions(tomlContent: string, versionChanges: import("../remediate.js").VersionChangeRequest[]): {
+    content: string;
+    applied: TomlAppliedChange[];
+    skipped: Array<{
+        groupId: string;
+        artifactId: string;
+        newVersion: string;
+        reason: string;
+    }>;
+};
+/**
+ * One entry in {@link updateTomlVersions}' `applied` list: a version that was changed and where.
+ * `type` discriminates the edit site — `'ref'` for a `[libraries]` entry pointing at a shared
+ * `[versions]` alias via `version.ref` (then `versionRef` names that alias), `'inline'` for a
+ * version declared directly on the library. `alias` is the library's catalog key in both cases.
+ */
+export type TomlAppliedChange = {
+    groupId: string;
+    artifactId: string;
+    newVersion: string;
+    oldVersion: string;
+    type: ("ref" | "inline");
+    alias: string;
+    versionRef?: string;
+};