@cyclonedx/cdxgen 10.2.1 → 10.2.3

package/index.js

@@ -4299,6 +4299,11 @@ export async function createCsharpBom(path, options) {
     return createBinaryBom(path, options);
   }
   const parentComponent = createDefaultParentComponent(path, "nuget", options);
+  const slnFiles = getAllFiles(
+    path,
+    (options.multiProject ? "**/" : "") + "*.sln",
+    options
+  );
   let csProjFiles = getAllFiles(
     path,
     (options.multiProject ? "**/" : "") + "*.csproj",
@@ -4315,7 +4320,7 @@ export async function createCsharpBom(path, options) {
     (options.multiProject ? "**/" : "") + "packages.config",
     options
   );
-  const projAssetsFiles = getAllFiles(
+  let projAssetsFiles = getAllFiles(
     path,
     (options.multiProject ? "**/" : "") + "project.assets.json",
     options
@@ -4335,6 +4340,45 @@ export async function createCsharpBom(path, options) {
     (options.multiProject ? "**/" : "") + "*.nupkg",
     options
   );
+  // Support for automatic restore
+  if (
+    options.installDeps &&
+    !projAssetsFiles.length &&
+    !pkgLockFiles.length &&
+    !paketLockFiles.length
+  ) {
+    const filesToRestore = slnFiles.length > 0 ? slnFiles : csProjFiles;
+    for (const f of filesToRestore) {
+      if (DEBUG_MODE) {
+        const basePath = dirname(f);
+        console.log("Executing 'dotnet restore' in", basePath);
+      }
+      const result = spawnSync(
+        "dotnet",
+        ["restore", "--force", "--ignore-failed-sources", f],
+        {
+          cwd: path,
+          encoding: "utf-8"
+        }
+      );
+      if (DEBUG_MODE && (result.status !== 0 || result.error)) {
+        console.error(
+          "Restore has failed. Check if dotnet is installed and available in PATH."
+        );
+        console.log(
+          "Authenticate with any private registries such as Azure Artifacts feed before running cdxgen."
+        );
+        console.log(result.stderr);
+        options.failOnError && process.exit(1);
+      }
+    }
+    // Collect the assets file generated from restore
+    projAssetsFiles = getAllFiles(
+      path,
+      (options.multiProject ? "**/" : "") + "project.assets.json",
+      options
+    );
+  }
   let pkgList = [];
   if (nupkgFiles.length && projAssetsFiles.length === 0) {
     manifestFiles = manifestFiles.concat(nupkgFiles);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cyclonedx/cdxgen",
-  "version": "10.2.1",
+  "version": "10.2.3",
   "description": "Creates CycloneDX Software Bill of Materials (SBOM) from source or container image",
   "homepage": "http://github.com/cyclonedx/cdxgen",
   "author": "Prabhu Subramanian <prabhu@appthreat.com>",
@@ -67,7 +67,7 @@
     "find-up": "7.0.0",
     "glob": "^10.3.10",
     "global-agent": "^3.0.0",
-    "got": "14.2.0",
+    "got": "14.2.1",
     "iconv-lite": "^0.6.3",
     "js-yaml": "^4.1.0",
     "jws": "^4.0.0",
@@ -114,6 +114,6 @@
     "eslint-plugin-prettier": "^5.1.3",
     "jest": "^29.7.0",
     "prettier": "3.2.5",
-    "typescript": "^5.3.3"
+    "typescript": "^5.4.2"
   }
 }

package/types/analyzer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../analyzer.js"],"names":[],"mappings":"AAgSO;;;GAkBN"}
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../analyzer.js"],"names":[],"mappings":"AAkSO;;;GAkBN"}

package/types/binary.d.ts

@@ -9,5 +9,22 @@ export function getOSPackages(src: any): {
     allTypes: any[];
 };
 export function executeOsQuery(query: any): any;
+/**
+ * Method to execute dosai to create slices for dotnet
+ *
+ * @param {string} src Source Path
+ * @param {string} slicesFile Slices file name
+ * @returns boolean
+ */
 export function getDotnetSlices(src: string, slicesFile: string): boolean;
+/**
+ * Method to generate binary SBOM using blint
+ *
+ * @param {string} src Path to binary or its directory
+ * @param {string} binaryBomFile Path to binary
+ * @param {boolean} deepMode Deep mode flag
+ *
+ * @return {boolean} Result of the generation
+ */
+export function getBinaryBom(src: string, binaryBomFile: string, deepMode: boolean): boolean;
 //# sourceMappingURL=binary.d.ts.map

package/types/binary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../binary.js"],"names":[],"mappings":"AA0QO,iDA8BN;AAEM,wDAmBN;AAEM;;;;;;;EA+UN;AAiCM,gDAgDN;AASM,qCAJI,MAAM,cACN,MAAM,WA2BhB"}
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../binary.js"],"names":[],"mappings":"AA6QA,iDA8BC;AAED,wDAmBC;AAED;;;;;;;EA+UC;AAiCD,gDAgDC;AAED;;;;;;GAMG;AACH,qCAJW,MAAM,cACN,MAAM,WA2BhB;AAED;;;;;;;;GAQG;AACH,kCANW,MAAM,iBACN,MAAM,YACN,OAAO,GAEN,OAAO,CA6BlB"}

package/types/evinser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evinser.d.ts","sourceRoot":"","sources":["../evinser.js"],"names":[],"mappings":"AAwBO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEN;AAEM,6GAiDN;AAEM,gGAkCN;AAEM,wGAqBN;AAEM;;;;EA4DN;AAEM,iEAoBN;AAEM;;;EA8BN;AAQM;;;;;;;;;;GAyGN;AAEM,2JA4CN;AAcM,2CARI,MAAM,iHAkNhB;AAEM,sGAoEN;AASM,mDAJI,MAAM,wCA6DhB;AASM,gDAJI,MAAM,mDA8DhB;AAEM,wEAWN;AAEM,gEAmDN;AASM,yEAgHN;AAaM,gDAPI,MAAM,uHAyHhB;AASM,iDAHI,MAAM,4BAqChB;AAQM,kDAaN;AAQM,2CAHI,MAAM,UAKhB;AAEM,oFAsCN"}
+{"version":3,"file":"evinser.d.ts","sourceRoot":"","sources":["../evinser.js"],"names":[],"mappings":"AAwBO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEN;AAEM,6GAiDN;AAEM,gGAkCN;AAEM,wGAqBN;AAEM;;;;EAiEN;AAEM,iEAoBN;AAEM;;;EA8BN;AAQM;;;;;;;;;;GAyGN;AAEM,2JA4CN;AAcM,2CARI,MAAM,iHAkNhB;AAEM,sGAoEN;AASM,mDAJI,MAAM,wCA6DhB;AASM,gDAJI,MAAM,mDA8DhB;AAEM,wEAWN;AAEM,gEAmDN;AASM,yEAgHN;AAaM,gDAPI,MAAM,uHAyHhB;AASM,iDAHI,MAAM,4BAqChB;AAQM,kDAaN;AAQM,2CAHI,MAAM,UAKhB;AAEM,oFAsCN"}

package/types/index.d.ts

@@ -9,40 +9,218 @@
  */
 export function listComponents(options: any, allImports: any, pkg: any, ptype?: string): any[];
 /**
- * Method to submit the generated bom to dependency-track or cyclonedx server
+ * Function to create bom string for Java jars
  *
- * @param {Object} args CLI args
- * @param {Object} bomContents BOM Json
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ *
+ * @returns {Object} BOM with namespace mapping
  */
-export function submitBom(args: any, bomContents: any): Promise<any>;
 export function createJarBom(path: string, options: any): any;
+/**
+ * Function to create bom string for Android apps using blint
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
+export function createAndroidBom(path: string, options: any): {
+    bomJson: any;
+    dependencies: any;
+    parentComponent: any;
+};
+/**
+ * Function to create bom string for binaries using blint
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
+export function createBinaryBom(path: string, options: any): {
+    bomJson: any;
+    dependencies: any;
+    parentComponent: any;
+};
+/**
+ * Function to create bom string for Java projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createJavaBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for Node.js projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createNodejsBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for Python projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createPythonBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for Go projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createGoBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for Rust projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createRustBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for Dart projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createDartBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for cpp projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createCppBom(path: string, options: any): any;
+/**
+ * Function to create bom string for clojure projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createClojureBom(path: string, options: any): any;
+/**
+ * Function to create bom string for Haskell projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createHaskellBom(path: string, options: any): any;
+/**
+ * Function to create bom string for Elixir projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createElixirBom(path: string, options: any): any;
+/**
+ * Function to create bom string for GitHub action workflows
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createGitHubBom(path: string, options: any): any;
+/**
+ * Function to create bom string for cloudbuild yaml
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createCloudBuildBom(path: string, options: any): any;
+/**
+ * Function to create obom string for the current OS using osquery
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createOSBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for Jenkins plugins
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createJenkinsBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for Helm charts
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createHelmBom(path: string, options: any): any;
+/**
+ * Function to create bom string for swift projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createSwiftBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for docker compose
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createContainerSpecLikeBom(path: string, options: any): any;
+/**
+ * Function to create bom string for php projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createPHPBom(path: string, options: any): any;
+/**
+ * Function to create bom string for ruby projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createRubyBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for csharp projects
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createCsharpBom(path: string, options: any): Promise<any>;
 export function mergeDependencies(dependencies: any, newDependencies: any, parentComponent?: {}): {
     ref: string;
     dependsOn: any[];
 }[];
 export function trimComponents(components: any): any[];
+/**
+ * Dedupe components
+ *
+ * @param {Object} options Options
+ * @param {Array} components Components
+ * @param {Object} parentComponent Parent component
+ * @param {Array} dependencies Dependencies
+ *
+ * @returns {Object} Object including BOM Json
+ */
 export function dedupeBom(options: any, components: any[], parentComponent: any, dependencies: any[]): any;
+/**
+ * Function to create bom string for all languages
+ *
+ * @param {string} pathList list of to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createMultiXBom(pathList: string, options: any): Promise<any>;
-export function createXBom(path: string, options: any): any;
+/**
+ * Function to create bom string for various languages
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
+export function createXBom(path: string, options: any): Promise<any>;
+/**
+ * Function to create bom string for various languages
+ *
+ * @param {string} path to the project
+ * @param {Object} options Parse options from the cli
+ */
 export function createBom(path: string, options: any): any;
+/**
+ * Method to submit the generated bom to dependency-track or cyclonedx server
+ *
+ * @param {Object} args CLI args
+ * @param {Object} bomContents BOM Json
+ */
+export function submitBom(args: any, bomContents: any): Promise<any>;
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"AA4oBA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AAyyJD;;;;;GAKG;AACH,qEAyFC;AAjmJM,mCALI,MAAM,qBAiEhB;AAQM,oCAHI,MAAM,8BAuvBhB;AAQM,sCAHI,MAAM,8BAkZhB;AAQM,sCAHI,MAAM,8BAgWhB;AAQM,kCAHI,MAAM,8BAiUhB;AAQM,oCAHI,MAAM,8BAiFhB;AAQM,oCAHI,MAAM,8BAgDhB;AAQM,mCAHI,MAAM,qBA+KhB;AAQM,uCAHI,MAAM,qBAqHhB;AAQM,uCAHI,MAAM,qBA2BhB;AAQM,sCAHI,MAAM,qBA2BhB;AAQM,sCAHI,MAAM,qBA2BhB;AAQM,0CAHI,MAAM,qBAuBhB;AAQM,kCAHI,MAAM,8BAqDhB;AAQM,uCAHI,MAAM,8BA4ChB;AAQM,oCAHI,MAAM,qBA2BhB;AAQM,qCAHI,MAAM,8BAwFhB;AAQM,iDAHI,MAAM,qBAkUhB;AAQM,mCAHI,MAAM,qBAwJhB;AAQM,oCAHI,MAAM,8BAmFhB;AAQM,sCAHI,MAAM,8BAoMhB;AAEM;;;IAkCN;AAEM,uDAWN;AAYM,2GAkCN;AAQM,0CAHI,MAAM,8BAgbhB;AAQM,iCAHI,MAAM,qBAmUhB;AAQM,gCAHI,MAAM,qBAmQhB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.js"],"names":[],"mappings":"AA6oBA;;;;;;;;GAQG;AACH,gFAFW,MAAM,SAchB;AA+RD;;;;;;;GAOG;AACH,mCALW,MAAM,qBAiEhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM;;;;EAKhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM;;;;EAkBhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAuvBhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAkZhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAgWhB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BAiUhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAiFhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAgDhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBA+KhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBAqHhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,0CAHW,MAAM,qBAuBhB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,8BAqDhB;AAED;;;;;GAKG;AACH,uCAHW,MAAM,8BA4ChB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,qBA2BhB;AAED;;;;;GAKG;AACH,qCAHW,MAAM,8BAwFhB;AAED;;;;;GAKG;AACH,iDAHW,MAAM,qBAkUhB;AAED;;;;;GAKG;AACH,mCAHW,MAAM,qBAwJhB;AAED;;;;;GAKG;AACH,oCAHW,MAAM,8BAmFhB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,8BAmPhB;AAED;;;IAkCC;AAED,uDAWC;AAED;;;;;;;;;GASG;AACH,2GA6BC;AAED;;;;;GAKG;AACH,0CAHW,MAAM,8BAgbhB;AAED;;;;;GAKG;AACH,iCAHW,MAAM,8BAmUhB;AAED;;;;;GAKG;AACH,gCAHW,MAAM,qBAiRhB;AAED;;;;;GAKG;AACH,qEAyFC"}

package/types/utils.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Method to get files matching a pattern
+ *
+ * @param {string} dirPath Root directory for search
+ * @param {string} pattern Glob pattern (eg: *.gradle)
+ */
+export function getAllFiles(dirPath: string, pattern: string, options?: {}): string[];
+/**
+ * Method to get files matching a pattern
+ *
+ * @param {string} dirPath Root directory for search
+ * @param {string} pattern Glob pattern (eg: *.gradle)
+ * @param {Array} ignoreList Directory patterns to ignore
+ */
+export function getAllFilesWithIgnore(dirPath: string, pattern: string, ignoreList: any[]): string[];
 /**
  * Performs a lookup + validation of the license specified in the
  * package. If the license is a valid SPDX license ID, set the 'id'
@@ -5,6 +20,14 @@
  * object.
  */
 export function getLicenses(pkg: any): any;
+/**
+ * Method to retrieve known license by known-licenses.json
+ *
+ * @param {String} licenseUrl Repository url
+ * @param {String} pkg Bom ref
+ * @return {Object} Objetct with SPDX license id or license name
+ */
+export function getKnownLicense(licenseUrl: string, pkg: string): any;
 /**
  * Tries to find a file containing the license text based on commonly
  * used naming and content types. If a candidate file is found, add
@@ -18,56 +41,61 @@ export function addLicenseText(pkg: any, l: any, licenseContent: any): void;
 export function readLicenseText(licenseFilepath: any, licenseContentType: any): {
     content: string;
 };
+export function getSwiftPackageMetadata(pkgList: any): Promise<any[]>;
 /**
- * Method to parse requirements.txt data
+ * Method to retrieve metadata for npm packages by querying npmjs
  *
- * @param {Object} reqData Requirements.txt data
- * @param {Boolean} fetchDepsInfo Fetch dependencies info from pypi
+ * @param {Array} pkgList Package list
  */
-export function parseReqFile(reqData: any, fetchDepsInfo: boolean): Promise<any[]>;
-export const dirNameStr: string;
-export const isWin: boolean;
-export const isMac: boolean;
-export let ATOM_DB: string;
-export const frameworksList: any;
-export const DEBUG_MODE: boolean;
-export const TIMEOUT_MS: number;
-export const MAX_BUFFER: number;
-export let metadata_cache: {};
-export const includeMavenTestScope: boolean;
-export const FETCH_LICENSE: boolean;
-export const SEARCH_MAVEN_ORG: boolean;
-export let JAVA_CMD: string;
-export let PYTHON_CMD: string;
-export let DOTNET_CMD: string;
-export let NODE_CMD: string;
-export let NPM_CMD: string;
-export let YARN_CMD: string;
-export let GCC_CMD: string;
-export let RUSTC_CMD: string;
-export let GO_CMD: string;
-export let CARGO_CMD: string;
-export let CLJ_CMD: string;
-export let LEIN_CMD: string;
-export let SWIFT_CMD: string;
-export const cdxgenAgent: any;
-export function getAllFiles(dirPath: string, pattern: string, options?: {}): string[];
-export function getAllFilesWithIgnore(dirPath: string, pattern: string, ignoreList: any[]): string[];
-export function getKnownLicense(licenseUrl: string, pkg: string): any;
-export function getSwiftPackageMetadata(pkgList: any): Promise<any[]>;
 export function getNpmMetadata(pkgList: any[]): Promise<any[]>;
+/**
+ * Parse nodejs package json file
+ *
+ * @param {string} pkgJsonFile package.json file
+ * @param {boolean} simple Return a simpler representation of the component by skipping extended attributes and license fetch.
+ */
 export function parsePkgJson(pkgJsonFile: string, simple?: boolean): Promise<any[]>;
+/**
+ * Parse nodejs package lock file
+ *
+ * @param {string} pkgLockFile package-lock.json file
+ * @param {object} options Command line options
+ */
 export function parsePkgLock(pkgLockFile: string, options?: object): Promise<{
     pkgList: any;
     dependenciesList: any;
 }>;
+/**
+ * Given a lock file this method would return an Object with the identiy as the key and parsed name and value
+ * eg: "@actions/core@^1.2.6", "@actions/core@^1.6.0":
+ *        version "1.6.0"
+ * would result in two entries
+ *
+ * @param {string} lockData Yarn Lockfile data
+ */
 export function yarnLockToIdentMap(lockData: string): {};
+/**
+ * Parse nodejs yarn lock file
+ *
+ * @param {string} yarnLockFile yarn.lock file
+ */
 export function parseYarnLock(yarnLockFile: string): Promise<{
     pkgList: any[];
     dependenciesList: any[];
 }>;
+/**
+ * Parse nodejs shrinkwrap deps file
+ *
+ * @param {string} swFile shrinkwrap-deps.json file
+ */
 export function parseNodeShrinkwrap(swFile: string): Promise<any[]>;
-export function parsePnpmLock(pnpmLock: string, parentComponent?: any): Promise<{
+/**
+ * Parse nodejs pnpm lock file
+ *
+ * @param {string} pnpmLock pnpm-lock.yaml file
+ * @param {object} parentComponent parent component
+ */
+export function parsePnpmLock(pnpmLock: string, parentComponent?: object): Promise<{
     pkgList?: undefined;
     dependenciesList?: undefined;
 } | {
@@ -77,8 +105,23 @@ export function parsePnpmLock(pnpmLock: string, parentComponent?: any): Promise<
         dependsOn: string[];
     }[];
 }>;
+/**
+ * Parse bower json file
+ *
+ * @param {string} bowerJsonFile bower.json file
+ */
 export function parseBowerJson(bowerJsonFile: string): Promise<any[]>;
+/**
+ * Parse minified js file
+ *
+ * @param {string} minJsFile min.js file
+ */
 export function parseMinJs(minJsFile: string): Promise<any[]>;
+/**
+ * Parse pom file
+ *
+ * @param {string} pom file to parse
+ */
 export function parsePom(pomFile: any): {
     group: any;
     name: any;
@@ -102,6 +145,10 @@ export function parsePom(pomFile: any): {
         };
     };
 }[];
+/**
+ * Parse maven tree output
+ * @param {string} rawOutput Raw string output
+ */
 export function parseMavenTree(rawOutput: string): {
     pkgList?: undefined;
     dependenciesList?: undefined;
@@ -112,6 +159,13 @@ export function parseMavenTree(rawOutput: string): {
         dependsOn: any;
     }[];
 };
+/**
+ * Parse gradle dependencies output
+ * @param {string} rawOutput Raw string output
+ * @param {string} rootProjectGroup Root project group
+ * @param {string} rootProjectName Root project name
+ * @param {string} rootProjectVersion Root project version
+ */
 export function parseGradleDep(rawOutput: string, rootProjectGroup?: string, rootProjectName?: string, rootProjectVersion?: string): {
     pkgList: {
         group: any;
@@ -129,13 +183,31 @@ export function parseGradleDep(rawOutput: string, rootProjectGroup?: string, roo
     pkgList?: undefined;
     dependenciesList?: undefined;
 };
+/**
+ * Parse clojure cli dependencies output
+ * @param {string} rawOutput Raw string output
+ */
 export function parseCljDep(rawOutput: string): any[];
+/**
+ * Parse lein dependency tree output
+ * @param {string} rawOutput Raw string output
+ */
 export function parseLeinDep(rawOutput: string): any;
 export function parseLeinMap(node: any, keys_cache: any, deps: any): any;
+/**
+ * Parse gradle projects output
+ *
+ * @param {string} rawOutput Raw string output
+ */
 export function parseGradleProjects(rawOutput: string): {
     rootProject: string;
     projects: any[];
 };
+/**
+ * Parse gradle properties output
+ *
+ * @param {string} rawOutput Raw string output
+ */
 export function parseGradleProperties(rawOutput: string): {
     rootProject: string;
     projects: any[];
@@ -145,28 +217,149 @@ export function parseGradleProperties(rawOutput: string): {
         properties: any[];
     };
 };
+/**
+ * Execute gradle properties command and return parsed output
+ *
+ * @param {string} dir Directory to execute the command
+ * @param {string} rootPath Root directory
+ * @param {string} subProject Sub project name
+ */
 export function executeGradleProperties(dir: string, rootPath: string, subProject: string): {};
+/**
+ * Parse bazel action graph output
+ * @param {string} rawOutput Raw string output
+ */
 export function parseBazelActionGraph(rawOutput: string): any[];
+/**
+ * Parse bazel skyframe state output
+ * @param {string} rawOutput Raw string output
+ */
 export function parseBazelSkyframe(rawOutput: string): any[];
+/**
+ * Parse bazel BUILD file
+ * @param {string} rawOutput Raw string output
+ */
 export function parseBazelBuild(rawOutput: string): any[];
+/**
+ * Parse dependencies in Key:Value format
+ */
 export function parseKVDep(rawOutput: any): any[];
+/**
+ * Method to find the spdx license id from name
+ *
+ * @param {string} name License full name
+ */
 export function findLicenseId(name: string): any;
+/**
+ * Method to guess the spdx license id from license contents
+ *
+ * @param {string} name License file contents
+ */
 export function guessLicenseId(content: any): any;
+/**
+ * Method to retrieve metadata for maven packages by querying maven central
+ *
+ * @param {Array} pkgList Package list
+ * @param {Object} jarNSMapping Jar Namespace mapping object
+ */
 export function getMvnMetadata(pkgList: any[], jarNSMapping?: any): Promise<any[]>;
+/**
+ * Method to compose URL of pom.xml
+ *
+ * @param {String} urlPrefix
+ * @param {String} group
+ * @param {String} name
+ * @param {String} version
+ *
+ * @return {String} fullUrl
+ */
 export function composePomXmlUrl({ urlPrefix, group, name, version }: string): string;
+/**
+ * Method to fetch pom.xml data and parse it to JSON
+ *
+ * @param {String} urlPrefix
+ * @param {String} group
+ * @param {String} name
+ * @param {String} version
+ *
+ * @return {Object|undefined}
+ */
 export function fetchPomXmlAsJson({ urlPrefix, group, name, version }: string): any | undefined;
+/**
+ * Method to fetch pom.xml data
+ *
+ * @param {String} urlPrefix
+ * @param {String} group
+ * @param {String} name
+ * @param {String} version
+ *
+ * @return {Promise<String>}
+ */
 export function fetchPomXml({ urlPrefix, group, name, version }: string): Promise<string>;
+/**
+ * Method extract single or multiple license entries that might appear in pom.xml
+ *
+ * @param {Object|Array} license
+ */
 export function parseLicenseEntryOrArrayFromPomXml(license: any | any[]): any[];
+/**
+ * Method to parse pom.xml in search of a comment containing license text
+ *
+ * @param {String} urlPrefix
+ * @param {String} group
+ * @param {String} name
+ * @param {String} version
+ *
+ * @return {Promise<String>} License ID
+ */
 export function extractLicenseCommentFromPomXml({ urlPrefix, group, name, version }: string): Promise<string>;
+/**
+ * Method to parse python requires_dist attribute found in pypi setup.py
+ *
+ * @param requires_dist string
+ */
 export function parsePyRequiresDist(dist_string: any): {
     name: string;
     version: string;
 };
+/**
+ * Method to mimic pip version solver using node-semver
+ *
+ * @param {Array} versionsList List of version numbers available
+ * @param {*} versionSpecifiers pip version specifier
+ */
 export function guessPypiMatchingVersion(versionsList: any[], versionSpecifiers: any): any;
+/**
+ * Method to retrieve metadata for python packages by querying pypi
+ *
+ * @param {Array} pkgList Package list
+ * @param {Boolean} fetchDepsInfo Fetch dependencies info from pypi
+ */
 export function getPyMetadata(pkgList: any[], fetchDepsInfo: boolean): Promise<any[]>;
+/**
+ * Method to parse bdist_wheel metadata
+ *
+ * @param {Object} mData bdist_wheel metadata
+ */
 export function parseBdistMetadata(mData: any): {}[];
+/**
+ * Method to parse pipfile.lock data
+ *
+ * @param {Object} lockData JSON data from Pipfile.lock
+ */
 export function parsePiplockData(lockData: any): Promise<any[]>;
+/**
+ * Method to parse python pyproject.toml file
+ *
+ * @param {string} tomlFile Toml file
+ */
 export function parsePyProjectToml(tomlFile: string): {};
+/**
+ * Method to parse poetry.lock data
+ *
+ * @param {Object} lockData JSON data from poetry.lock
+ * @param {string} lockFile Lock file name for evidence
+ */
 export function parsePoetrylockData(lockData: any, lockFile: string): Promise<any[] | {
     pkgList: any[];
     rootList: any[];
@@ -175,6 +368,20 @@ export function parsePoetrylockData(lockData: any, lockFile: string): Promise<an
         dependsOn: any[];
     }[];
 }>;
+/**
+ * Method to parse requirements.txt data
+ *
+ * @param {Object} reqData Requirements.txt data
+ * @param {Boolean} fetchDepsInfo Fetch dependencies info from pypi
+ */
+export function parseReqFile(reqData: any, fetchDepsInfo: boolean): Promise<any[]>;
+/**
+ * Method to find python modules by parsing the imports and then checking with PyPI to obtain the latest version
+ *
+ * @param {string} src directory
+ * @param {Array} epkgList Existing package list
+ * @returns List of packages
+ */
 export function getPyModules(src: string, epkgList: any[], options: any): Promise<{
     allImports: {};
     pkgList: any;
@@ -184,18 +391,67 @@ export function getPyModules(src: string, epkgList: any[], options: any): Promis
     }[];
     modList: any;
 }>;
+/**
+ * Method to parse setup.py data
+ *
+ * @param {Object} setupPyData Contents of setup.py
+ */
 export function parseSetupPyFile(setupPyData: any): Promise<any[]>;
+/**
+ * Method to construct a GitHub API url for the given repo metadata
+ * @param {Object} repoMetadata Repo metadata with group and name
+ * @return {String|undefined} github api url (or undefined - if not enough data)
+ */
 export function repoMetadataToGitHubApiUrl(repoMetadata: any): string | undefined;
+/**
+ * Method to split GitHub url into its parts
+ * @param {String} repoUrl Repository url
+ * @return {[String]} parts from url
+ */
 export function getGithubUrlParts(repoUrl: string): [string];
+/**
+ * Method to construct GitHub api url from repo metadata or one of multiple formats of repo URLs
+ * @param {String} repoUrl Repository url
+ * @param {Object} repoMetadata Object containing group and package name strings
+ * @return {String|undefined} github api url (or undefined - if not a GitHub repo)
+ */
 export function toGitHubApiUrl(repoUrl: string, repoMetadata: any): string | undefined;
+/**
+ * Method to retrieve repo license by querying github api
+ *
+ * @param {String} repoUrl Repository url
+ * @param {Object} repoMetadata Object containing group and package name strings
+ * @return {Promise<String>} SPDX license id
+ */
 export function getRepoLicense(repoUrl: string, repoMetadata: any): Promise<string>;
+/**
+ * Method to get go pkg license from go.dev site.
+ *
+ * @param {Object} repoMetadata Repo metadata
+ */
 export function getGoPkgLicense(repoMetadata: any): Promise<any>;
 export function getGoPkgComponent(group: any, name: any, version: any, hash: any): Promise<{}>;
 export function parseGoModData(goModData: any, gosumMap: any): Promise<any[]>;
+/**
+ * Parse go list output
+ *
+ * @param {string} rawOutput Output from go list invocation
+ * @returns Object with parent component and List of packages
+ */
 export function parseGoListDep(rawOutput: string, gosumMap: any): Promise<{
     parentComponent: {};
     pkgList: {}[];
 }>;
+/**
+ * Parse go mod graph
+ *
+ * @param {string} rawOutput Output from go mod graph invocation
+ * @param {string} goModFile go.mod file
+ * @param {Object} goSumMap Hashes from gosum for lookups
+ * @param {Array} epkgList Existing package list
+ *
+ * @returns Object containing List of packages and dependencies
+ */
 export function parseGoModGraph(rawOutput: string, goModFile: string, gosumMap: any, epkgList?: any[], parentComponent?: {}): Promise<{
     pkgList: any[];
     dependenciesList: {
@@ -203,13 +459,38 @@ export function parseGoModGraph(rawOutput: string, goModFile: string, gosumMap:
         dependsOn: any[];
     }[];
 }>;
+/**
+ * Parse go mod why output
+ * @param {string} rawOutput Output from go mod why
+ * @returns package name or none
+ */
 export function parseGoModWhy(rawOutput: string): any;
-export function parseGosumData(gosumData: any): Promise<any[]>;
+/**
+ * Parse go sum data
+ * @param {string} gosumData Content of go.sum
+ * @returns package list
+ */
+export function parseGosumData(gosumData: string): Promise<any[]>;
 export function parseGopkgData(gopkgData: any): Promise<any[]>;
 export function parseGoVersionData(buildInfoData: any): Promise<any[]>;
-export const RUBY_PLATFORM_PREFIXES: string[];
+/**
+ * Method to query rubygems api for gems details
+ *
+ * @param {Array} pkgList List of packages with metadata
+ */
 export function getRubyGemsMetadata(pkgList: any[]): Promise<any[]>;
+/**
+ * Method to parse Gemspec
+ *
+ * @param {string} gemspecData Gemspec data
+ */
 export function parseGemspecData(gemspecData: string): Promise<any[]>;
+/**
+ * Method to parse Gemfile.lock
+ *
+ * @param {object} gemLockData Gemfile.lock data
+ * @param {string} lockFile Lock file
+ */
 export function parseGemfileLockData(gemLockData: object, lockFile: string): Promise<any[] | {
     pkgList: any[];
     dependenciesList: {
@@ -225,9 +506,25 @@ export function parseGemfileLockData(gemLockData: object, lockFile: string): Pro
     }[];
     rootList: any[];
 }>;
+/**
+ * Method to retrieve metadata for rust packages by querying crates
+ *
+ * @param {Array} pkgList Package list
+ */
 export function getCratesMetadata(pkgList: any[]): Promise<any[]>;
+/**
+ * Method to retrieve metadata for dart packages by querying pub.dev
+ *
+ * @param {Array} pkgList Package list
+ */
 export function getDartMetadata(pkgList: any[]): Promise<any[]>;
-export function parseCargoTomlData(cargoData: any): Promise<any[]>;
+/**
+ * Method to parse cargo.toml data
+ *
+ * @param {string} cargoData Content of cargo.toml
+ * @returns {array} Package list
+ */
+export function parseCargoTomlData(cargoData: string): any[];
 export function parseCargoData(cargoData: any): Promise<any[]>;
 export function parseCargoAuditableData(cargoData: any): Promise<any[]>;
 export function parsePubLockData(pubLockData: any): Promise<any[]>;
@@ -269,6 +566,12 @@ export function parsePaketLockData(paketLockData: any, pkgLockFile: any): {
     pkgList: any[];
     dependenciesList: any[];
 };
+/**
+ * Parse composer lock file
+ *
+ * @param {string} pkgLockFile composer.lock file
+ * @param {array} rootRequires require section from composer.json
+ */
 export function parseComposerLock(pkgLockFile: string, rootRequires: any[]): any[] | {
     pkgList: {
         group: string;
@@ -334,6 +637,11 @@ export function parseSbtTree(sbtTreeFile: any): {
         dependsOn: any;
     }[];
 };
+/**
+ * Parse sbt lock file
+ *
+ * @param {string} pkgLockFile build.sbt.lock file
+ */
 export function parseSbtLock(pkgLockFile: string): {
     group: any;
     name: any;
@@ -356,11 +664,49 @@ export function parseSbtLock(pkgLockFile: string): {
         };
     };
 }[];
+/**
+ * Method to execute dpkg --listfiles to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
 export function executeDpkgList(pkgName: string): string[];
+/**
+ * Method to execute dnf repoquery to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
 export function executeRpmList(pkgName: string): string[];
+/**
+ * Method to execute apk -L info to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
 export function executeApkList(pkgName: string): string[];
+/**
+ * Method to execute alpm -Ql to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
 export function executeAlpmList(pkgName: string): string[];
+/**
+ * Method to execute equery files to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
 export function executeEqueryList(pkgName: string): string[];
+/**
+ * Convert OS query results
+ *
+ * @param {string} Query category
+ * @param {Object} queryObj Query Object from the queries.json configuration
+ * @param {Array} results Query Results
+ * @param {Boolean} enhance Optionally enhance results by invoking additional package manager commands
+ */
 export function convertOSQueryResults(queryCategory: any, queryObj: any, results: any[], enhance?: boolean): {
     name: any;
     group: string;
@@ -372,7 +718,17 @@ export function convertOSQueryResults(queryCategory: any, queryObj: any, results
     scope: any;
     type: any;
 }[];
+/**
+ * Parse swift dependency tree output json object
+ * @param {string} jsonObject Swift dependencies json object
+ * @param {string} pkgFile Package.swift file
+ */
 export function parseSwiftJsonTreeObject(pkgList: any, dependenciesList: any, jsonObject: string, pkgFile: string): string;
+/**
+ * Parse swift dependency tree output
+ * @param {string} rawOutput Swift dependencies json output
+ * @param {string} pkgFile Package.swift file
+ */
 export function parseSwiftJsonTree(rawOutput: string, pkgFile: string): {
     pkgList?: undefined;
     dependenciesList?: undefined;
@@ -380,6 +736,10 @@ export function parseSwiftJsonTree(rawOutput: string, pkgFile: string): {
     pkgList: any[];
     dependenciesList: any[];
 };
+/**
+ * Parse swift package resolved file
+ * @param {string} resolvedFile Package.resolved file
+ */
 export function parseSwiftResolved(resolvedFile: string): {
     name: string;
     group: string;
@@ -402,8 +762,24 @@ export function parseSwiftResolved(resolvedFile: string): {
         };
     };
 }[];
+/**
+ * Collect maven dependencies
+ *
+ * @param {string} mavenCmd Maven command to use
+ * @param {string} basePath Path to the maven project
+ * @param {boolean} cleanup Remove temporary directories
+ * @param {boolean} includeCacheDir Include maven and gradle cache directories
+ */
 export function collectMvnDependencies(mavenCmd: string, basePath: string, cleanup?: boolean, includeCacheDir?: boolean): Promise<{}>;
 export function collectGradleDependencies(gradleCmd: any, basePath: any, cleanup?: boolean, includeCacheDir?: boolean): Promise<{}>;
+/**
+ * Method to collect class names from all jars in a directory
+ *
+ * @param {string} jarPath Path containing jars
+ * @param {object} pomPathMap Map containing jar to pom names. Required to successfully parse gradle cache.
+ *
+ * @return object containing jar name and class list
+ */
 export function collectJarNS(jarPath: string, pomPathMap?: object): Promise<{}>;
 export function convertJarNSToPackages(jarNSMapping: any): {
     name: any;
@@ -439,19 +815,115 @@ export function parsePomXml(pomXmlData: any): {
 export function parseJarManifest(jarMetadata: any): {};
 export function parsePomProperties(pomProperties: any): {};
 export function encodeForPurl(s: any): any;
+/**
+ * Method to get pom properties from maven directory
+ *
+ * @param {string} mavenDir Path to maven directory
+ *
+ * @return array with pom properties
+ */
 export function getPomPropertiesFromMavenDir(mavenDir: string): {};
+/**
+ * Method to extract a war or ear file
+ *
+ * @param {string} jarFile Path to jar file
+ * @param {string} tempDir Temporary directory to use for extraction
+ * @param {object} jarNSMapping Jar class names mapping object
+ *
+ * @return pkgList Package list
+ */
 export function extractJarArchive(jarFile: string, tempDir: string, jarNSMapping?: object): Promise<any[]>;
+/**
+ * Determine the version of SBT used in compilation of this project.
+ * By default it looks into a standard SBT location i.e.
+ * <path-project>/project/build.properties
+ * Returns `null` if the version cannot be determined.
+ *
+ * @param {string} projectPath Path to the SBT project
+ */
 export function determineSbtVersion(projectPath: string): any;
+/**
+ * Adds a new plugin to the SBT project by amending its plugins list.
+ * Only recommended for SBT < 1.2.0 or otherwise use `addPluginSbtFile`
+ * parameter.
+ * The change manipulates the existing plugins' file by creating a copy of it
+ * and returning a path where it is moved to.
+ * Once the SBT task is complete one must always call `cleanupPlugin` to remove
+ * the modifications made in place.
+ *
+ * @param {string} projectPath Path to the SBT project
+ * @param {string} plugin Name of the plugin to add
+ */
 export function addPlugin(projectPath: string, plugin: string): string;
+/**
+ * Cleans up modifications to the project's plugins' file made by the
+ * `addPlugin` function.
+ *
+ * @param {string} projectPath Path to the SBT project
+ * @param {string} originalPluginsFile Location of the original plugins file, if any
+ */
 export function cleanupPlugin(projectPath: string, originalPluginsFile: string): boolean;
+/**
+ * Returns a default location of the plugins file.
+ *
+ * @param {string} projectPath Path to the SBT project
+ */
 export function sbtPluginsPath(projectPath: string): string;
+/**
+ * Method to read a single file entry from a zip file
+ *
+ * @param {string} zipFile Zip file to read
+ * @param {string} filePattern File pattern
+ * @param {string} contentEncoding Encoding. Defaults to utf-8
+ *
+ * @returns File contents
+ */
 export function readZipEntry(zipFile: string, filePattern: string, contentEncoding?: string): Promise<any>;
+/**
+ * Method to get the classes and relevant sources in a jar file
+ *
+ * @param {string} jarFile Jar file to read
+ *
+ * @returns List of classes and sources matching certain known patterns
+ */
 export function getJarClasses(jarFile: string): Promise<any[]>;
+/**
+ * Method to return the gradle command to use.
+ *
+ * @param {string} srcPath Path to look for gradlew wrapper
+ * @param {string} rootPath Root directory to look for gradlew wrapper
+ */
 export function getGradleCommand(srcPath: string, rootPath: string): string;
+/**
+ * Method to return the maven command to use.
+ *
+ * @param {string} srcPath Path to look for maven wrapper
+ * @param {string} rootPath Root directory to look for maven wrapper
+ */
 export function getMavenCommand(srcPath: string, rootPath: string): string;
+/**
+ * Retrieves the atom command by referring to various environment variables
+ */
 export function getAtomCommand(): any;
 export function executeAtom(src: any, args: any): boolean;
+/**
+ * Find the imported modules in the application with atom parsedeps command
+ *
+ * @param {string} src
+ * @param {string} language
+ * @param {string} methodology
+ * @param {string} slicesFile
+ * @returns List of imported modules
+ */
 export function findAppModules(src: string, language: string, methodology?: string, slicesFile?: string): any;
+/**
+ * Execute pip freeze by creating a virtual env in a temp directory and construct the dependency tree
+ *
+ * @param {string} basePath Base path
+ * @param {string} reqOrSetupFile Requirements or setup.py file
+ * @param {string} tempVenvDir Temp venv dir
+ * @returns List of packages from the virtual env
+ */
 export function getPipFrozenTree(basePath: string, reqOrSetupFile: string, tempVenvDir: string): {
     pkgList: {
         name: any;
@@ -486,6 +958,13 @@ export function parsePackageJsonName(name: any): {
     projectName: string;
     moduleName: string;
 };
+/**
+ * Method to add occurrence evidence for components based on import statements. Currently useful for js
+ *
+ * @param {array} pkgList List of package
+ * @param {object} allImports Import statements object with package name as key and an object with file and location details
+ * @param {object} allExports Exported modules if available from node_modules
+ */
 export function addEvidenceForImports(pkgList: any[], allImports: object, allExports: object, deep: any): Promise<any[]>;
 export function componentSorter(a: any, b: any): any;
 export function parseCmakeDotFile(dotFile: any, pkgType: any, options?: {}): {
@@ -501,6 +980,14 @@ export function parseCmakeLikeFile(cmakeListFile: any, pkgType: any, options?: {
     pkgList: any[];
 };
 export function getOSPackageForFile(afile: any, osPkgsList: any): any;
+/**
+ * Method to find c/c++ modules by collecting usages with atom
+ *
+ * @param {string} src directory
+ * @param {object} options Command line options
+ * @param {array} osPkgsList Array of OS pacakges represented as components
+ * @param {array} epkgList Existing packages list
+ */
 export function getCppModules(src: string, options: object, osPkgsList: any[], epkgList: any[]): {
     parentComponent: {};
     pkgList: any[];
@@ -509,11 +996,50 @@ export function getCppModules(src: string, options: object, osPkgsList: any[], e
         dependsOn: any[];
     }[];
 };
+/**
+ * NOT IMPLEMENTED YET.
+ * A future method to locate a generic package given some name and properties
+ *
+ * @param {object} apkg Package to locate
+ * @returns Located project with precise purl or the original unmodified input.
+ */
 export function locateGenericPackage(apkg: object): any;
 export function parseCUsageSlice(sliceData: any): {};
+/**
+ * Method to retrieve metadata for nuget packages
+ *
+ * @param {Array} pkgList Package list
+ */
 export function getNugetMetadata(pkgList: any[], dependencies?: any): Promise<{
     pkgList: any[];
     dependencies: any[];
 }>;
 export function addEvidenceForDotnet(pkgList: any, slicesFile: any): any;
+export const dirNameStr: string;
+export const isWin: boolean;
+export const isMac: boolean;
+export let ATOM_DB: string;
+export const frameworksList: any;
+export const DEBUG_MODE: boolean;
+export const TIMEOUT_MS: number;
+export const MAX_BUFFER: number;
+export let metadata_cache: {};
+export const includeMavenTestScope: boolean;
+export const FETCH_LICENSE: boolean;
+export const SEARCH_MAVEN_ORG: boolean;
+export let JAVA_CMD: string;
+export let PYTHON_CMD: string;
+export let DOTNET_CMD: string;
+export let NODE_CMD: string;
+export let NPM_CMD: string;
+export let YARN_CMD: string;
+export let GCC_CMD: string;
+export let RUSTC_CMD: string;
+export let GO_CMD: string;
+export let CARGO_CMD: string;
+export let CLJ_CMD: string;
+export let LEIN_CMD: string;
+export let SWIFT_CMD: string;
+export const cdxgenAgent: any;
+export const RUBY_PLATFORM_PREFIXES: string[];
 //# sourceMappingURL=utils.d.ts.map

package/types/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../utils.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../utils.js"],"names":[],"mappings":"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"}