@trustify-da/trustify-da-javascript-client 0.3.0-ea.e12bc82 → 0.3.0-ea.e258fba

package/dist/src/providers/java_gradle.js

@@ -1,14 +1,19 @@
+import crypto from 'node:crypto';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { EOL } from 'os';
-import TOML from 'fast-toml';
+import { parse as parseToml } from 'smol-toml';
+import { readLicenseFile } from '../license/license_utils.js';
 import Sbom from '../sbom.js';
+import { invokeCommand } from '../tools.js';
+import { filterManifestPathsByDiscoveryIgnore, resolveWorkspaceDiscoveryIgnore } from '../workspace.js';
 import Base_java, { ecosystem_gradle } from "./base_java.js";
 /** @typedef {import('../provider.js').Provider} */
 /** @typedef {import('../provider.js').Provided} Provided */
 const ROOT_PROJECT_KEY_NAME = "root-project";
-const TRUSTIFY_DA_IGNORE_REGEX_LINE = /.*\s?exhortignore\s*$/g;
-const TRUSTIFY_DA_IGNORE_REGEX = /\/\/\s?exhortignore/;
+const TRUSTIFY_DA_IGNORE_REGEX_LINE = /.*\s?(exhortignore|trustify-da-ignore)\s*$/g;
+const TRUSTIFY_DA_IGNORE_REGEX = /\/\/\s?(exhortignore|trustify-da-ignore)/;
 /**
  * Check if the dependency marked for exclusion has libs notation , so if it's true the rest of coordinates( GAV) should be fetched from TOML file.
  * @param {string} depToBeIgnored
@@ -49,16 +54,22 @@ export default class Java_gradle extends Base_java {
      * @param {string} manifestDir - the directory where the manifest lies
      */
     validateLockFile() { return true; }
+    /**
+     * Gradle manifests (build.gradle, build.gradle.kts) have no standard license field.
+     * @param {string} manifestPath - path to manifest
+     * @returns {null}
+     */
+    readLicenseFromManifest(manifestPath) { return readLicenseFile(manifestPath); }
     /**
      * Provide content and content type for stack analysis.
      * @param {string} manifest - the manifest path or name
      * @param {{}} [opts={}] - optional various options to pass along the application
      * @returns {Provided}
      */
-    provideStack(manifest, opts = {}) {
+    async provideStack(manifest, opts = {}) {
         return {
             ecosystem: ecosystem_gradle,
-            content: this.#createSbomStackAnalysis(manifest, opts),
+            content: await this.#createSbomStackAnalysis(manifest, opts),
             contentType: 'application/vnd.cyclonedx+json'
         };
     }
@@ -68,10 +79,10 @@ export default class Java_gradle extends Base_java {
      * @param {{}} [opts={}] - optional various options to pass along the application
      * @returns {Provided}
      */
-    provideComponent(manifest, opts = {}) {
+    async provideComponent(manifest, opts = {}) {
         return {
             ecosystem: ecosystem_gradle,
-            content: this.#getSbomForComponentAnalysis(manifest, opts),
+            content: await this.#getSbomForComponentAnalysis(manifest, opts),
             contentType: 'application/vnd.cyclonedx+json'
         };
     }
@@ -121,9 +132,10 @@ export default class Java_gradle extends Base_java {
      * @param {Sbom} sbom - the SBOM object to add dependencies to
      * @param {Set} processedDeps - set of already processed dependencies
      * @param {string} scope - the dependency scope
+     * @param {Map<string, Array<{alg: string, content: string}>>} [hashMap] - map of "group:name@version" to CycloneDX hashes
      * @private
      */
-    #processDependencyTree(config, parentPurl, sbom, processedDeps, scope) {
+    #processDependencyTree(config, parentPurl, sbom, processedDeps, scope, hashMap) {
         const processedLines = this.#prepareLinesForParsingDependencyTree(config);
         let parentStack = [parentPurl];
         for (const { line, depth } of processedLines) {
@@ -141,7 +153,7 @@ export default class Java_gradle extends Base_java {
                 // Add dependency to SBOM if not already processed
                 if (!processedDeps.has(depKey)) {
                     processedDeps.add(depKey);
-                    sbom.addDependency(currentParent, purl, scope);
+                    sbom.addDependency(currentParent, purl, scope, hashMap?.get(purl.toString()));
                 }
                 parentStack.push(purl);
             }
@@ -154,16 +166,17 @@ export default class Java_gradle extends Base_java {
      * @returns {string} the Dot Graph content
      * @private
      */
-    #buildSbom(content, properties, manifestPath, opts = {}) {
+    #buildSbom(content, properties, manifestPath, opts = {}, hashMap) {
         let sbom = new Sbom();
         let root = `${properties.group}:${properties[ROOT_PROJECT_KEY_NAME].match(/Root project '(.+)'/)[1]}:jar:${properties.version}`;
         let rootPurl = this.parseDep(root);
-        sbom.addRoot(rootPurl);
+        const license = this.readLicenseFromManifest(manifestPath);
+        sbom.addRoot(rootPurl, license);
         let ignoredDeps = this.#getIgnoredDeps(manifestPath);
         const [runtimeConfig, compileConfig] = this.#extractConfigurations(content);
         const processedDeps = new Set();
-        this.#processDependencyTree(runtimeConfig, rootPurl, sbom, processedDeps, 'required');
-        this.#processDependencyTree(compileConfig, rootPurl, sbom, processedDeps, 'optional');
+        this.#processDependencyTree(runtimeConfig, rootPurl, sbom, processedDeps, 'required', hashMap);
+        this.#processDependencyTree(compileConfig, rootPurl, sbom, processedDeps, 'optional', hashMap);
         return sbom.filterIgnoredDepsIncludingVersion(ignoredDeps).getAsJsonString(opts);
     }
     /**
@@ -173,14 +186,15 @@ export default class Java_gradle extends Base_java {
      * @returns {string} the Dot Graph content
      * @private
      */
-    #createSbomStackAnalysis(manifest, opts = {}) {
+    async #createSbomStackAnalysis(manifest, opts = {}) {
         let content = this.#getDependencies(manifest, opts);
         let properties = this.#extractProperties(manifest, opts);
+        let hashMap = await this.parseGradleHashes(manifest, opts);
         // read dependency tree from temp file
         if (process.env["TRUSTIFY_DA_DEBUG"] === "true") {
             console.log("Dependency tree that will be used as input for creating the BOM =>" + EOL + EOL + content);
         }
-        let sbom = this.#buildSbom(content, properties, manifest, opts);
+        let sbom = this.#buildSbom(content, properties, manifest, opts, hashMap);
         return sbom;
     }
     /**
@@ -225,10 +239,11 @@ export default class Java_gradle extends Base_java {
      * @returns {string} - sbom string of the direct dependencies of build.gradle
      * @private
      */
-    #getSbomForComponentAnalysis(manifestPath, opts = {}) {
+    async #getSbomForComponentAnalysis(manifestPath, opts = {}) {
         let content = this.#getDependencies(manifestPath, opts);
         let properties = this.#extractProperties(manifestPath, opts);
-        let sbom = this.#buildDirectDependenciesSbom(content, properties, manifestPath, opts);
+        let hashMap = await this.parseGradleHashes(manifestPath, opts);
+        let sbom = this.#buildDirectDependenciesSbom(content, properties, manifestPath, opts, hashMap);
         return sbom;
     }
     /**
@@ -247,6 +262,112 @@ export default class Java_gradle extends Base_java {
             throw new Error(`Couldn't run gradle dependencies command, error message returned from gradle binary => ${EOL} ${error.message}`);
         }
     }
+    /**
+     * Hash a file using SHA-256 with streaming to handle large files efficiently.
+     * @param {string} filePath - path to the file to hash
+     * @returns {Promise<string>} hex-encoded SHA-256 digest
+     * @private
+     */
+    #hashFileStream(filePath) {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('sha256');
+            const stream = fs.createReadStream(filePath);
+            stream.on('data', chunk => hash.update(chunk));
+            stream.on('end', () => resolve(hash.digest('hex')));
+            stream.on('error', reject);
+        });
+    }
+    /**
+     * Compute SHA-256 hashes for the resolved artifacts of a Gradle manifest.
+     *
+     * Rather than scanning the local Gradle cache, this asks Gradle itself for
+     * the resolved artifact files via an init script (mirroring the pattern used
+     * by {@link discoverGradleSubprojects}), then hashes each file with the
+     * Node.js `crypto` module. The result is keyed by the canonical PURL string
+     * built via {@link Base_java#toPurl} — the same builder {@link parseDep} uses
+     * for the lookup — so the stored key and the lookup key cannot drift.
+     *
+     * Degrades gracefully: if Gradle cannot be invoked, the init script fails, or
+     * an artifact has no readable file (e.g. BOM/`platform()` dependencies), the
+     * hash for that component is omitted rather than throwing. A warning is emitted
+     * on every degradation path so incomplete hash coverage is visible even without
+     * `TRUSTIFY_DA_DEBUG` (mirroring the pip/cargo providers).
+     *
+     * @param {string} manifest - path to build.gradle[.kts]
+     * @param {{}} [opts={}] - optional various options to pass along the application
+     * @returns {Promise<Map<string, Array<{alg: string, content: string}>>>} map of canonical PURL string to CycloneDX hashes
+     */
+    async parseGradleHashes(manifest, opts = {}) {
+        const hashMap = new Map();
+        const debug = process.env["TRUSTIFY_DA_DEBUG"] === "true";
+        let gradle;
+        try {
+            gradle = this.selectToolBinary(manifest, opts);
+        }
+        catch (error) {
+            console.warn(`Gradle could not be invoked to compute artifact hashes, SBOM will be generated without hashes: ${error.stack || error.message}`);
+            return hashMap;
+        }
+        const initScriptPath = path.join(os.tmpdir(), `da-list-hashes-${crypto.randomUUID()}.gradle`);
+        try {
+            fs.writeFileSync(initScriptPath, GRADLE_HASH_INIT_SCRIPT);
+            let output;
+            try {
+                output = this._invokeCommand(gradle, [
+                    '-q', '--no-daemon',
+                    '--init-script', initScriptPath,
+                    'daListHashes',
+                ], { cwd: path.dirname(manifest) });
+            }
+            catch (error) {
+                console.warn(`Gradle hash init script failed, SBOM will be generated without hashes: ${error.stack || error.message}`);
+                return hashMap;
+            }
+            let attempted = 0;
+            let missed = 0;
+            for (const { id, file } of parseGradleHashScriptOutput(output.toString())) {
+                const coord = parseComponentId(id);
+                if (!coord) {
+                    continue;
+                }
+                // Build the key with the same canonical PURL builder parseDep uses for
+                // the lookup, so the stored key and the lookup key cannot drift.
+                const key = this.toPurl(coord.group, coord.name, coord.version).toString();
+                if (hashMap.has(key)) {
+                    continue;
+                }
+                attempted++;
+                try {
+                    const digest = await this.#hashFileStream(file);
+                    hashMap.set(key, [{ alg: 'SHA-256', content: digest }]);
+                }
+                catch (error) {
+                    // artifact file missing/unreadable — omit the hash for this component
+                    missed++;
+                    if (debug) {
+                        console.error(`Gradle hash: could not read artifact ${file} => ${error.message}`);
+                    }
+                }
+            }
+            if (missed > 0) {
+                console.warn(`Gradle hash: ${missed} of ${attempted} resolved artifacts could not be read, SBOM will be generated without hashes for those components`);
+            }
+        }
+        catch (error) {
+            // Unexpected failure (e.g. a programming error) is degraded to keep SBOM
+            // generation working, but the error is surfaced so it is not mistaken
+            // for ordinary graceful degradation.
+            console.warn(`Gradle artifact hashing failed, SBOM will be generated without hashes: ${error.stack || error.message}`);
+            return hashMap;
+        }
+        finally {
+            try {
+                fs.unlinkSync(initScriptPath);
+            }
+            catch { /* ignore */ }
+        }
+        return hashMap;
+    }
     /**
      * Extracts runtime and compile configurations from the dependency tree
      * @param {string} content - the dependency tree content
@@ -294,11 +415,12 @@ export default class Java_gradle extends Base_java {
      * @param properties {Object} - properties of the gradle project.
      * @return {string} return sbom json string of the build.gradle manifest file
      */
-    #buildDirectDependenciesSbom(content, properties, manifestPath, opts = {}) {
+    #buildDirectDependenciesSbom(content, properties, manifestPath, opts = {}, hashMap) {
         let sbom = new Sbom();
         let root = `${properties.group}:${properties[ROOT_PROJECT_KEY_NAME].match(/Root project '(.+)'/)[1]}:jar:${properties.version}`;
         let rootPurl = this.parseDep(root);
-        sbom.addRoot(rootPurl);
+        const license = this.readLicenseFromManifest(manifestPath);
+        sbom.addRoot(rootPurl, license);
         let ignoredDeps = this.#getIgnoredDeps(manifestPath);
         const [runtimeConfig, compileConfig] = this.#extractConfigurations(content);
         let directDependencies = new Map();
@@ -307,7 +429,7 @@ export default class Java_gradle extends Base_java {
         directDependencies.forEach((scope, dep) => {
             const purl = this.parseDep(dep);
             purl.scope = scope;
-            sbom.addDependency(rootPurl, purl, scope);
+            sbom.addDependency(rootPurl, purl, scope, hashMap?.get(purl.toString()));
         });
         return sbom.filterIgnoredDepsIncludingVersion(ignoredDeps).getAsJsonString(opts);
     }
@@ -352,7 +474,7 @@ export default class Java_gradle extends Base_java {
         // Read and parse the TOML file
         let pathOfToml = path.join(path.dirname(manifestPath), "gradle", "libs.versions.toml");
         const tomlString = fs.readFileSync(pathOfToml).toString();
-        let tomlObject = TOML.parse(tomlString);
+        let tomlObject = parseToml(tomlString);
         let groupPlusArtifactObject = tomlObject.libraries[alias];
         let parts = groupPlusArtifactObject.module.split(":");
         let groupId = parts[0];
@@ -397,3 +519,183 @@ export default class Java_gradle extends Base_java {
         return undefined;
     }
 }
+const DEFAULT_GRADLE_DISCOVERY_IGNORE = [
+    '**/build/**',
+    '**/.gradle/**',
+];
+/** Gradle init script that emits structured project listing. */
+const GRADLE_INIT_SCRIPT = `allprojects {
+    task daListProjects {
+        doLast {
+            println "::DA_PROJECT::\${project.path}::\${project.projectDir}"
+        }
+    }
+}
+`;
+/**
+ * Gradle init script that emits, per resolved module artifact, a structured line
+ * of the form `::DA_HASH::group:name:version::/absolute/file/path`. It obtains
+ * files from Gradle's resolution API (the same approach as the CycloneDX Gradle
+ * plugin) so it is robust to cache-layout changes and correctly reports
+ * classifiers and non-jar artifacts. Uses a lenient artifact view so
+ * unresolved/fileless artifacts are skipped rather than failing the build.
+ */
+const GRADLE_HASH_INIT_SCRIPT = `allprojects {
+    task daListHashes {
+        doLast {
+            configurations.findAll { it.canBeResolved }.each { cfg ->
+                cfg.incoming.artifactView { lenient = true }.artifacts.each { artifact ->
+                    def cid = artifact.id.componentIdentifier
+                    if (cid instanceof org.gradle.api.artifacts.component.ModuleComponentIdentifier) {
+                        println "::DA_HASH::\${cid.group}:\${cid.module}:\${cid.version}::\${artifact.file.absolutePath}"
+                    }
+                }
+            }
+        }
+    }
+}
+`;
+/**
+ * Discover all build.gradle[.kts] manifest paths in a Gradle multi-project build.
+ * Uses a custom init script to get structured project listing.
+ *
+ * @param {string} workspaceRoot - Absolute or relative path to workspace root (must contain settings.gradle[.kts])
+ * @param {import('../index.js').Options} [opts={}]
+ * @returns {Promise<string[]>} Paths to build.gradle[.kts] files (absolute)
+ */
+export async function discoverGradleSubprojects(workspaceRoot, opts = {}) {
+    const root = path.resolve(workspaceRoot);
+    const hasSettings = fs.existsSync(path.join(root, 'settings.gradle'))
+        || fs.existsSync(path.join(root, 'settings.gradle.kts'));
+    if (!hasSettings) {
+        return [];
+    }
+    const manifestPaths = [];
+    const rootBuildKts = path.join(root, 'build.gradle.kts');
+    const rootBuild = path.join(root, 'build.gradle');
+    const rootManifest = fs.existsSync(rootBuildKts) ? rootBuildKts : fs.existsSync(rootBuild) ? rootBuild : null;
+    if (rootManifest) {
+        manifestPaths.push(rootManifest);
+    }
+    let gradleBin;
+    try {
+        gradleBin = new Java_gradle().selectToolBinary(rootManifest || rootBuild, opts);
+    }
+    catch {
+        const ignorePatterns = [...resolveWorkspaceDiscoveryIgnore(opts), ...DEFAULT_GRADLE_DISCOVERY_IGNORE];
+        return filterManifestPathsByDiscoveryIgnore(manifestPaths, root, ignorePatterns);
+    }
+    const initScriptPath = path.join(os.tmpdir(), `da-list-projects-${crypto.randomUUID()}.gradle`);
+    try {
+        fs.writeFileSync(initScriptPath, GRADLE_INIT_SCRIPT);
+        let output;
+        try {
+            output = invokeCommand(gradleBin, [
+                '-q', '--no-daemon',
+                '--init-script', initScriptPath,
+                'daListProjects',
+            ], { cwd: root });
+        }
+        catch {
+            const ignorePatterns = [...resolveWorkspaceDiscoveryIgnore(opts), ...DEFAULT_GRADLE_DISCOVERY_IGNORE];
+            return filterManifestPathsByDiscoveryIgnore(manifestPaths, root, ignorePatterns);
+        }
+        const projects = parseGradleInitScriptOutput(output.toString());
+        for (const proj of projects) {
+            if (proj.path === ':') {
+                continue;
+            }
+            const projDir = path.resolve(proj.dir);
+            const buildKts = path.join(projDir, 'build.gradle.kts');
+            const buildGroovy = path.join(projDir, 'build.gradle');
+            if (fs.existsSync(buildKts)) {
+                manifestPaths.push(buildKts);
+            }
+            else if (fs.existsSync(buildGroovy)) {
+                manifestPaths.push(buildGroovy);
+            }
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(initScriptPath);
+        }
+        catch { /* ignore */ }
+    }
+    const ignorePatterns = [...resolveWorkspaceDiscoveryIgnore(opts), ...DEFAULT_GRADLE_DISCOVERY_IGNORE];
+    return filterManifestPathsByDiscoveryIgnore(manifestPaths, root, ignorePatterns);
+}
+/**
+ * Parse the structured output from the Gradle init script.
+ *
+ * @param {string} raw - Raw stdout from gradle
+ * @returns {{ path: string, dir: string }[]}
+ */
+export function parseGradleInitScriptOutput(raw) {
+    const projects = [];
+    for (const rawLine of raw.split('\n')) {
+        const line = rawLine.trimEnd();
+        if (!line.startsWith('::DA_PROJECT::')) {
+            continue;
+        }
+        const prefix = '::DA_PROJECT::';
+        const remainder = line.substring(prefix.length);
+        const lastSep = remainder.lastIndexOf('::');
+        if (lastSep < 0) {
+            continue;
+        }
+        const projPath = remainder.substring(0, lastSep);
+        const dir = remainder.substring(lastSep + 2);
+        if (projPath && dir) {
+            projects.push({ path: projPath, dir });
+        }
+    }
+    return projects;
+}
+/**
+ * Parse the structured output from the Gradle hash init script.
+ * Each recognised line has the form `::DA_HASH::group:name:version::<file-path>`.
+ *
+ * @param {string} raw - Raw stdout from gradle
+ * @returns {{ id: string, file: string }[]} component id (`group:name:version`) and absolute artifact file path
+ */
+export function parseGradleHashScriptOutput(raw) {
+    const artifacts = [];
+    for (const rawLine of raw.split('\n')) {
+        const line = rawLine.trimEnd();
+        if (!line.startsWith('::DA_HASH::')) {
+            continue;
+        }
+        const prefix = '::DA_HASH::';
+        const remainder = line.substring(prefix.length);
+        const lastSep = remainder.lastIndexOf('::');
+        if (lastSep < 0) {
+            continue;
+        }
+        const id = remainder.substring(0, lastSep);
+        const file = remainder.substring(lastSep + 2);
+        if (id && file) {
+            artifacts.push({ id, file });
+        }
+    }
+    return artifacts;
+}
+/**
+ * Parse a Gradle module component id (`group:name:version`) into its coordinate
+ * parts. The caller builds the canonical PURL key from these parts using the same
+ * builder {@link parseDep} uses, so the stored key and the lookup key cannot drift.
+ *
+ * @param {string} id - the Gradle component id
+ * @returns {{group: string, name: string, version: string}|null} the parsed coordinate, or null when the id is malformed
+ */
+export function parseComponentId(id) {
+    const parts = id.split(':');
+    if (parts.length < 3) {
+        return null;
+    }
+    const [group, name, version] = parts;
+    if (!group || !name || !version) {
+        return null;
+    }
+    return { group, name, version };
+}

package/dist/src/providers/java_gradle_groovy.d.ts

@@ -3,5 +3,5 @@ export default class Java_gradle_groovy extends Java_gradle {
     _parseAliasForLibsNotation(alias: any): any;
     _extractDepToBeIgnored(dep: any): any;
 }
-export type Provided = import('../provider').Provided;
+export type Provided = any;
 import Java_gradle from './java_gradle.js';

package/dist/src/providers/java_gradle_kotlin.d.ts

@@ -7,5 +7,5 @@ export default class Java_gradle_kotlin extends Java_gradle {
     _parseAliasForLibsNotation(alias: any): any;
     _extractDepToBeIgnored(dep: any): string | null;
 }
-export type Provided = import('../provider').Provided;
+export type Provided = any;
 import Java_gradle from './java_gradle.js';

package/dist/src/providers/java_maven.d.ts

@@ -1,8 +1,16 @@
-/** @typedef {import('../provider').Provider} */
-/** @typedef {import('../provider').Provided} Provided */
-/** @typedef {{name: string, version: string}} Package */
-/** @typedef {{groupId: string, artifactId: string, version: string, scope: string, ignore: boolean}} Dependency */
+/**
+ * Discover all pom.xml manifest paths in a Maven multi-module project.
+ *
+ * @param {string} workspaceRoot - Absolute or relative path to workspace root (must contain pom.xml)
+ * @param {object} [opts={}]
+ * @returns {Promise<string[]>} Paths to pom.xml files (absolute)
+ */
+export function discoverMavenModules(workspaceRoot: string, opts?: object): Promise<string[]>;
 export default class Java_maven extends Base_java {
+    /** @type {Object<string, string>} Packaging types that produce .jar files despite non-jar packaging names. */
+    static PACKAGING_TO_JAR: {
+        [x: string]: string;
+    };
     constructor();
     /**
      * @param {string} manifestName - the subject manifest name-type
@@ -17,27 +25,54 @@ export default class Java_maven extends Base_java {
      * Provide content and content type for maven-maven stack analysis.
      * @param {string} manifest - the manifest path or name
      * @param {{}} [opts={}] - optional various options to pass along the application
-     * @returns {Provided}
+     * @returns {Promise<Provided>}
      */
-    provideStack(manifest: string, opts?: {} | undefined): Provided;
+    provideStack(manifest: string, opts?: {}): Promise<Provided>;
     /**
      * Provide content and content type for maven-maven component analysis.
      * @param {string} manifest - path to the manifest file
      * @param {{}} [opts={}] - optional various options to pass along the application
      * @returns {Provided}
      */
-    provideComponent(manifest: string, opts?: {} | undefined): Provided;
+    provideComponent(manifest: string, opts?: {}): Provided;
+    /**
+     * Read license from pom.xml manifest, with fallback to LICENSE file
+     * @param {string} manifestPath - path to pom.xml
+     * @returns {string|null}
+     */
+    readLicenseFromManifest(manifestPath: string): string | null;
     /**
+     * Build a Map of PURL string → CycloneDX hash entries by reading artifact files from the local Maven repository.
      *
+     * Both the artifact file path and the hash-map key are derived from the
+     * shared {@link Base_java#parseCoordinate} parser: the file path uses the
+     * resolved version and raw classifier, while the key uses the same canonical
+     * PURL builder as {@link Base_java#parseDep}. This guarantees the key always
+     * matches the PURL that {@link Base_java#parseDependencyTree} looks up.
+     *
+     * @param {string} depTreeText Raw dependency tree text from mvn dependency:tree
+     * @param {{}} [opts={}] Options bag (may contain TRUSTIFY_DA_MVN_REPO)
+     * @returns {Promise<Map<string, Array<{alg: string, content: string}>>>}
+     */
+    _buildMavenHashMap(depTreeText: string, opts?: {}): Promise<Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>>;
+    /**
      * @param {String} textGraphList Text graph String of the manifest
      * @param {[String]} ignoredDeps List of ignored dependencies to be omitted from sbom
+     * @param {{}} opts Options
+     * @param {String} manifestPath Path to the pom.xml manifest
+     * @param {Map<string, Array<{alg: string, content: string}>>} [hashMap] PURL→hashes map
      * @return {String} formatted sbom Json String with all dependencies
      */
-    createSbomFileFromTextFormat(textGraphList: string, ignoredDeps: [string], opts: any): string;
+    createSbomFileFromTextFormat(textGraphList: string, ignoredDeps: [string], opts: {}, manifestPath: string, hashMap?: Map<string, Array<{
+        alg: string;
+        content: string;
+    }>>): string;
     #private;
 }
-export type Java_maven = import('../provider').Provider;
-export type Provided = import('../provider').Provided;
+export type Provided = any;
 export type Package = {
     name: string;
     version: string;