@cdxgen/cdxgen 0.0.1 → 13.0.0

package/types/lib/evinser/evinser.d.ts

@@ -0,0 +1,354 @@
+/**
+ * Function to create the db for the libraries referred in the sbom.
+ *
+ * @param {Object} options Command line options
+ */
+export declare function prepareDB(options: Object): Promise<{
+    sequelize: {
+        close: () => boolean;
+    };
+    Namespaces: Object;
+    Usages: Object;
+    DataFlows: Object;
+} | undefined>;
+/**
+ * Collect Maven jar namespace mappings for the purls found in the SBOM.
+ *
+ * If a previously generated `bom.json.map` is present in `dirPath` it is reused;
+ * otherwise the maven command is invoked to collect the jar dependencies. Each
+ * resolved purl is recorded in the `purlsJars` map and persisted in the
+ * `Namespaces` model.
+ *
+ * @param {string} dirPath Project directory scanned by evinse
+ * @param {Object<string, string>} purlsJars Map populated with purl -> jar file path
+ * @param {Object} Namespaces Sequelize-like Namespaces model used to persist pom and namespaces
+ * @param {object} options CLI options
+ * @returns {Promise<void>}
+ */
+export declare function catalogMavenDeps(dirPath: string, purlsJars: Record<string, string>, Namespaces: Object, options?: object): Promise<void>;
+/**
+ * Collect Gradle cache jar namespace mappings for the purls found in the SBOM.
+ *
+ * Invokes the gradle command to collect all jars (including from the cache) and
+ * records each resolved purl in the `purlsJars` map and the `Namespaces` model.
+ *
+ * @param {string} dirPath Project directory scanned by evinse
+ * @param {Object<string, string>} purlsJars Map populated with purl -> jar file path
+ * @param {Object} Namespaces Sequelize-like Namespaces model used to persist pom and namespaces
+ * @returns {Promise<void>}
+ */
+export declare function catalogGradleDeps(dirPath: string, purlsJars: Record<string, string>, Namespaces: Object): Promise<void>;
+/**
+ * Generate a usage slice for the given purl and persist it in the Usages model.
+ *
+ * Delegates to {@link createSlice} to produce the slice file, then stores the
+ * file contents in the `Usages` model keyed by purl. Any temporary directory
+ * created under the cdxgen temp root is cleaned up afterwards.
+ *
+ * @param {string} purl Package URL to slice
+ * @param {Object<string, string>} purlsJars Map of purl -> jar/file path
+ * @param {Object} Usages Sequelize-like Usages model used to persist slice data
+ * @param {object} options CLI options
+ * @returns {Promise<Object|undefined>} The created or found Usages record
+ */
+export declare function createAndStoreSlice(purl: string, purlsJars: Record<string, string>, Usages: Object, options?: object): Promise<Object | undefined>;
+/**
+ * Name the option a slice type reads its output path from.
+ *
+ * The CLI flags are hyphenated (`--data-flow-slices-file`) and yargs hands them
+ * over camel-cased, so a slice type containing a hyphen cannot be turned into
+ * its option name by concatenation alone.
+ *
+ * @param {string} sliceType Slice type such as `usages` or `data-flow`
+ * @returns {string} Matching option name
+ */
+export declare function sliceFileOption(sliceType: string): string;
+/**
+ * Run atom/sourcekitten/dosai to produce a usage or data-flow slice file for a purl or language.
+ *
+ * Accepts either a package url (resolved to a language via {@link purlToLanguage})
+ * or an explicit language string. The chosen language is normalised to the
+ * canonical atom language name and the requested slice type (`usages`,
+ * `data-flow`, `reachables`, or `semantics`) is generated into a temporary
+ * directory.
+ *
+ * @param {string|string[]} purlOrLanguages Package URL or language name (or array whose first entry is used)
+ * @param {string} filePath Path to the source file, jar, or project directory to slice
+ * @param {string} [sliceType="usages"] Slice type: `usages`, `data-flow`, `reachables`, or `semantics`
+ * @param {object} [options={}] CLI options controlling slice generation
+ * @returns {Promise<Object>} Result map with `slicesFile`, `atomFile`, `openapiSpecFile`, `semanticsSlicesFile`, `tempDir`, and `tempDirOwned`
+ */
+export declare function createSlice(purlOrLanguages: string | string[], filePath: string, sliceType?: string, options?: object): Promise<Object>;
+/**
+ * Map a package URL type to an analysis language (java, python, js, …).
+ *
+ * @param {string} purl Package URL to inspect
+ * @param {string} [filePath] Optional file path used to distinguish jar vs java for maven purls
+ * @returns {string|undefined} Resolved language name or `undefined` when the purl type is unsupported
+ */
+export declare function purlToLanguage(purl: string, filePath?: string): string | undefined;
+/**
+ * Seed purl-location and import maps from SBOM component evidence.
+ *
+ * Walks the supplied components reading `internal:ImportedModules` (or
+ * `internal:Namespaces` for php/ruby) and `evidence.occurrences` properties
+ * to construct lookup maps used during slice analysis.
+ *
+ * @param {Object[]} components CycloneDX components from the input SBOM
+ * @param {string} language Application language used to select the import property name
+ * @returns {{ purlLocationMap: Object<string, Set>, purlImportsMap: Object<string, string[]> }} Seeded purl location and import maps
+ */
+export declare function initFromSbom(components: Object[], language: string): {
+    purlLocationMap: Record<string, Set<any>>;
+    purlImportsMap: Record<string, string[]>;
+};
+/**
+ * Function to analyze the project
+ *
+ * @param {Object} dbObjMap DB and model instances
+ * @param {Object} options Command line options
+ */
+export declare function analyzeProject(dbObjMap: Object, options: Object): Promise<{
+    purlLocationMap: Record<string, Set<any>>;
+    servicesMap: {};
+    dataFlowFrames: {};
+    userDefinedTypesMap: {};
+    componentPropertiesMap?: undefined;
+    metadataProperties?: undefined;
+    atomFile?: undefined;
+    usagesSlicesFile?: undefined;
+    dataFlowSlicesFile?: undefined;
+    reachablesSlicesFile?: undefined;
+    semanticsSlicesFile?: undefined;
+    tempDir?: undefined;
+    tempDirOwned?: undefined;
+    cryptoComponents?: undefined;
+    cryptoGeneratePurls?: undefined;
+    openapiSpecFile?: undefined;
+} | {
+    purlLocationMap: any;
+    dataFlowFrames: any;
+    componentPropertiesMap: any;
+    metadataProperties: any;
+    cryptoComponents: any;
+    cryptoGeneratePurls: any;
+    servicesMap: {};
+    userDefinedTypesMap: {};
+    atomFile?: undefined;
+    usagesSlicesFile?: undefined;
+    dataFlowSlicesFile?: undefined;
+    reachablesSlicesFile?: undefined;
+    semanticsSlicesFile?: undefined;
+    tempDir?: undefined;
+    tempDirOwned?: undefined;
+    openapiSpecFile?: undefined;
+} | {
+    componentPropertiesMap?: undefined;
+    metadataProperties?: undefined;
+    usagesSlicesFile: any;
+    dataFlowSlicesFile: any;
+    semanticsSlicesFile: any;
+    purlLocationMap: Record<string, Set<any>>;
+    servicesMap: {};
+    dataFlowFrames: {};
+    tempDir: any;
+    tempDirOwned: any;
+    userDefinedTypesMap: {};
+    cryptoComponents: any[];
+    cryptoGeneratePurls: {};
+    atomFile?: undefined;
+    reachablesSlicesFile?: undefined;
+    openapiSpecFile?: undefined;
+} | {
+    componentPropertiesMap?: undefined;
+    metadataProperties?: undefined;
+    atomFile: any;
+    usagesSlicesFile: any;
+    dataFlowSlicesFile: any;
+    reachablesSlicesFile: any;
+    semanticsSlicesFile: any;
+    purlLocationMap: Record<string, Set<any>>;
+    servicesMap: {};
+    dataFlowFrames: {};
+    tempDir: any;
+    tempDirOwned: any;
+    userDefinedTypesMap: {};
+    cryptoComponents: any[];
+    cryptoGeneratePurls: {};
+    openapiSpecFile: any;
+}>;
+/**
+ * Parse atom object slices into usages, user-defined types, services, and purl-location evidence.
+ *
+ * Iterates over the `objectSlices` and `userDefinedTypes` of an atom usage slice,
+ * delegating to {@link parseSliceUsages} to record purl locations and imports.
+ * Services are detected first from an OpenAPI spec (when present) and then from
+ * usage slices or user-defined types as fallbacks.
+ *
+ * @param {string} language Application language
+ * @param {Object} usageSlice Parsed atom usage slice object
+ * @param {Object} dbObjMap DB models handle containing Namespaces and Usages models
+ * @param {Object} [servicesMap={}] Map populated with detected service definitions
+ * @param {Object<string, Set>} [purlLocationMap={}] Map populated with purl -> source locations
+ * @param {Object<string, string[]>} [purlImportsMap={}] Map populated with purl -> imported modules
+ * @param {string} [openapiSpecFile=undefined] Optional path to an OpenAPI spec used for service detection
+ * @returns {Promise<Object>} Map with `purlLocationMap`, `servicesMap`, and `userDefinedTypesMap`
+ */
+export declare function parseObjectSlices(language: string, usageSlice: Object, dbObjMap: Object, servicesMap?: Object, purlLocationMap?: Record<string, Set<any>>, purlImportsMap?: Record<string, string[]>, openapiSpecFile?: string): Promise<Object>;
+/**
+ * The implementation of this function is based on the logic proposed in the atom slices specification
+ * https://github.com/AppThreat/atom/blob/main/specification/docs/slices.md#use
+ *
+ * @param {string} language Application language
+ * @param {Object} userDefinedTypesMap User Defined types in the application
+ * @param {Array} slice Usages array for each objectSlice
+ * @param {Object} dbObjMap DB Models
+ * @param {Object} purlLocationMap Object to track locations where purls are used
+ * @param {Object} purlImportsMap Object to track package urls and their import aliases
+ * @returns
+ */
+export declare function parseSliceUsages(language: string, userDefinedTypesMap: Object, slice: any[], dbObjMap: Object, purlLocationMap: Object, purlImportsMap: Object): Promise<void>;
+/**
+ * Method to parse semantic slice data. Currently supported for swift and scala languages.
+ *
+ * @param {String} language Project language.
+ * @param {Array} components Components from the input SBOM
+ * @param {Object} semanticsSlice Semantic slice data
+ * @returns {Object} Parsed metadata
+ */
+export declare function parseSemanticSlices(language: string, components: any[], semanticsSlice: Object): Object;
+/**
+ * Decide whether a type name should be ignored during slice analysis.
+ *
+ * Returns `true` for placeholder/builtin/unresolved names and for language
+ * specific primitives and JDK/runtime packages. User-defined types recorded in
+ * `userDefinedTypesMap` are also considered filterable.
+ *
+ * @param {string} language Application language
+ * @param {Object<string, boolean>} userDefinedTypesMap Known user-defined type names
+ * @param {string} typeFullName Full type name to test
+ * @returns {boolean} `true` when the type should be filtered out
+ */
+export declare function isFilterableType(language: string, userDefinedTypesMap: Record<string, boolean>, typeFullName: string): boolean;
+/**
+ * Extract service and endpoint definitions from an OpenAPI spec file.
+ *
+ * Parses the JSON spec and, for every operation under `paths`, records a
+ * service entry keyed by the URL pattern and HTTP method into `servicesMap`.
+ *
+ * @param {string} _language Application language (unused; reserved for future use)
+ * @param {string} openapiSpecFile Path to the OpenAPI JSON spec file
+ * @param {Object} servicesMap Map populated with detected services
+ * @returns {void}
+ */
+export declare function detectServicesFromOpenAPI(_language: string, openapiSpecFile: string, servicesMap: Object): void;
+/**
+ * Method to detect services from annotation objects in the usage slice
+ *
+ * @param {string} language Application language
+ * @param {Array} slice Usages array for each objectSlice
+ * @param {Object} servicesMap Existing service map
+ */
+export declare function detectServicesFromUsages(language: string, slice: any[], servicesMap?: Object): never[] | undefined;
+/**
+ * Method to detect services from user defined types in the usage slice
+ *
+ * @param {string} language Application language
+ * @param {Array} userDefinedTypes User defined types
+ * @param {Object} servicesMap Existing service map
+ */
+export declare function detectServicesFromUDT(language: string, userDefinedTypes: any[], servicesMap: Object): void;
+/**
+ * Derive a service name from a slice's fullName or file name.
+ *
+ * Uses the portion of `slice.fullName` before the first `:` (dots replaced with
+ * hyphens), falling back to the file basename. A `-service` suffix is appended
+ * when not already present.
+ *
+ * @param {string} _language Application language (unused; reserved for future use)
+ * @param {Object} slice Object slice containing `fullName` and/or `fileName`
+ * @returns {string} Constructed service name
+ */
+export declare function constructServiceName(_language: string, slice: Object): string;
+/**
+ * Extract HTTP endpoint paths from source code annotations for a given language.
+ *
+ * Examines the supplied code snippet for framework-specific routing annotations
+ * (e.g. Spring `@*Mapping`, Express `app.`/`route`, Rails route verbs) and
+ * returns the matched endpoint path strings.
+ *
+ * @param {string} language Application language such as `java`, `js`, or `ruby`
+ * @param {string} code Source code snippet to inspect
+ * @returns {string[]|undefined} Array of endpoint paths or `undefined` when none are found
+ */
+export declare function extractEndpoints(language: string, code: string): string[] | undefined;
+/**
+ * Method to create the SBOM with evidence file called evinse file.
+ *
+ * @param {Object} sliceArtefacts Various artefacts from the slice operation
+ * @param {Object} options Command line options
+ * @returns
+ */
+export declare function createEvinseFile(sliceArtefacts: Object, options: Object): any;
+/**
+ * Method to convert dataflow slice into usable callstack frames
+ * Implemented based on the logic proposed here - https://github.com/AppThreat/atom/blob/main/specification/docs/slices.md#data-flow-slice
+ *
+ * @param {string} language Application language
+ * @param {Object} userDefinedTypesMap User Defined types in the application
+ * @param {Object} dataFlowSlice Data flow slice object from atom
+ * @param {Object} dbObjMap DB models
+ * @param {Object} _purlLocationMap Object to track locations where purls are used
+ * @param {Object} purlImportsMap Object to track package urls and their import aliases
+ */
+export declare function collectDataFlowFrames(language: string, userDefinedTypesMap: Object, dataFlowSlice: Object, dbObjMap: Object, _purlLocationMap: Object, purlImportsMap: Object): Promise<{}>;
+/**
+ * Method to convert reachable slice into usable callstack frames and crypto components
+ *
+ * Implemented based on the logic proposed here - https://github.com/AppThreat/atom/blob/main/specification/docs/slices.md#data-flow-slice
+ *
+ * @param {string} _language Application language
+ * @param {Object} reachablesSlice Reachables slice object from atom
+ */
+export declare function collectReachableFrames(_language: string, reachablesSlice: Object): {
+    dataFlowFrames: {};
+    cryptoComponents: {
+        type: string;
+        name: any;
+        "bom-ref": any;
+        description: any;
+        cryptoProperties: {
+            assetType: string;
+            oid: any;
+        };
+    }[];
+    cryptoGeneratePurls: {};
+};
+/**
+ * Method to pick a callstack frame as an evidence. This method is required since CycloneDX 1.5 accepts only a single frame as evidence.
+ *
+ * @param {Array} dfFrames Data flow frames
+ * @returns
+ */
+export declare function framePicker(dfFrames: any[]): any[] | undefined;
+/**
+ * Method to simplify types. For example, arrays ending with [] could be simplified.
+ *
+ * @param {string} typeFullName Full name of the type to simplify
+ * @returns Simplified type string
+ */
+export declare function simplifyType(typeFullName: string): string;
+/**
+ * Reduce a full type signature to its enclosing class type for a given language.
+ *
+ * Strips method, call, and member qualifiers from the signature using language
+ * specific rules (e.g. java method selectors, javascript `::`/`new`/`await`,
+ * python module/body suffixes) and returns the simplified class type via
+ * {@link simplifyType}.
+ *
+ * @param {string} language Application language
+ * @param {string} typeFullName Full type signature to reduce
+ * @returns {string|undefined} Enclosing class type or `undefined` when it cannot be resolved
+ */
+export declare function getClassTypeFromSignature(language: string, typeFullName: string): string | undefined;
+//# sourceMappingURL=evinser.d.ts.map

package/types/lib/evinser/evinser.d.ts.map

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

package/types/lib/evinser/scalasem.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Map Scala semantic-slice used types back to purls and their source locations.
+ *
+ * Builds a type-to-purl cache from the component `internal:Namespaces`
+ * properties, then for each `.scala` entry in the semantic slice records the
+ * source file locations where each used type's purl appears.
+ *
+ * @param {Object[]} components CycloneDX components carrying namespace properties
+ * @param {Object} semanticsSlice Parsed Scala semantic slice object keyed by source file
+ * @returns {{ purlLocationMap: Object<string, string[]> }} Map of purl to sorted source location arrays
+ */
+export declare function findPurlLocations(components: Object[], semanticsSlice: Object): {
+    purlLocationMap: Record<string, string[]>;
+};
+//# sourceMappingURL=scalasem.d.ts.map

package/types/lib/evinser/scalasem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalasem.d.ts","sourceRoot":"","sources":["../../../lib/evinser/scalasem.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAJjC,MAAM,EAI2B,EAAE,cAAc,EAHjD,MAGiD,GAF/C;IAAE,eAAe,2BAA0B;CAAE,CAgCzD"}

package/types/lib/evinser/swiftsem.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Retrieve the structure information of a .swift file in json format
+ *
+ * @param {String} filePath Path to .swift file
+ *
+ * @returns {undefined|Object} JSON representation of the swift file or undefined.
+ */
+export declare function getStructure(filePath: string): undefined | Object;
+/**
+ * Parse the data from the structure command
+ *
+ * @param {Object} structureJson Json from the structure command
+ * @returns {Object|undefined} Parsed value
+ */
+export declare function parseStructure(structureJson: Object): Object | undefined;
+/**
+ * Method to perform swift build in verbose mode.
+ *
+ * @param {String} basePath Path
+ * @returns {undefined|String} Verbose build output
+ */
+export declare function verboseBuild(basePath: string): undefined | string;
+/**
+ * Method to parse the verbose swift build output to identify key compiler parameters.
+ *
+ * @param {String} buildOutput Verbose build output
+ * @returns {Object} compiler build parameters
+ */
+export declare function extractCompilerParamsFromBuild(buildOutput: string): Object;
+/**
+ * Method to index a swift file and extract metadata
+ *
+ * @param {String} filePath Path to .swift file
+ * @param {String|Array<string>} compilerArgs Compiler arguments extracted from verbose build log
+ * @returns {undefined|Object} metadata
+ */
+export declare function index(filePath: string, compilerArgs: string | Array<string>): undefined | Object;
+/**
+ * Parse the data from the index command
+ *
+ * @param {Object} indexJson Json from the index command
+ * @returns {Object|undefined} Parsed value
+ */
+export declare function parseIndex(indexJson: Object): Object | undefined;
+/**
+ * Method to execute dump-package package command.
+ *
+ * @param {String} basePath Path
+ * @returns {undefined|Object} Output from dump-package command
+ */
+export declare function dumpPackage(basePath: string): undefined | Object;
+/**
+ * Parse the data from dump-package command
+ *
+ * @param {Object} dumpJson Json from dump-package command
+ * @returns {Object|undefined} Parsed value
+ */
+export declare function parseDumpPackage(dumpJson: Object): Object | undefined;
+/**
+ * Retrieve the module information of the swift project
+ *
+ * @param {String} moduleName Module name
+ * @param {String|Array<string>} compilerArgs Compiler arguments extracted from verbose build log
+ * @returns {undefined|Object} JSON representation of the swift module or undefined.
+ */
+export declare function moduleInfo(moduleName: string, compilerArgs: string | Array<string>): undefined | Object;
+/**
+ * Parse the data from module-info command to replicate the swift interface
+ *
+ * @param {Object} moduleInfoJson Json from module-info command
+ * @returns {Object|undefined} Parsed classes, protocols, enums and their functions
+ */
+export declare function parseModuleInfo(moduleInfoJson: Object): Object | undefined;
+/**
+ * Method to collect the build symbols from the output file maps generated by swift build.
+ *
+ * @param {String} basePath Path
+ * @param {Object} options CLI options
+ * @returns {Object} symbols map
+ */
+export declare function collectBuildSymbols(basePath: string, options: Object): Object;
+/**
+ * Method to parse output file map to identify the module and their symbols.
+ * This list is imprecise when compared with the data from module-info command.
+ *
+ * @param filemap {String} File name
+ * @returns {Object} parsed module metadata
+ */
+export declare function parseOutputFileMap(filemap: string): Object;
+/**
+ * Create a precise semantics slices file for a swift project.
+ *
+ * @param basePath basePath Path
+ * @param options options CLI options
+ */
+export declare function createSemanticsSlices(basePath: any, options: any): {
+    packageMetadata: Object | undefined;
+    buildSymbols: Object;
+    moduleInfos: {};
+    fileStructures: {};
+    fileIndexes: {};
+} | undefined;
+//# sourceMappingURL=swiftsem.d.ts.map

package/types/lib/evinser/swiftsem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swiftsem.d.ts","sourceRoot":"","sources":["../../../lib/evinser/swiftsem.js"],"names":[],"mappings":"AAwEA;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,QAAA,GAFxB,SAAS,GAAC,MAAM,CAI5B;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAHjC,MAGiC,GAF/B,MAAM,GAAC,SAAS,CAiB5B;AAqCD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,QAAA,GAFxB,SAAS,SAAO,CAa5B;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,WAAW,QAAA,GAF7C,MAAM,CA+JlB;AAED;;;;;;GAMG;AACH,wBAAgB,KAAK,CAAC,QAAQ,QAAA,EAAE,YAAY,EAHjC,SAAO,KAAK,CAAC,MAAM,CAGc,GAF/B,SAAS,GAAC,MAAM,CAc5B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAHzB,MAGyB,GAFvB,MAAM,GAAC,SAAS,CA6B5B;AAsED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,QAAQ,QAAA,GAFvB,SAAS,GAAC,MAAM,CAY5B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAH9B,MAG8B,GAF5B,MAAM,GAAC,SAAS,CA4B5B;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,QAAA,EAAE,YAAY,EAHxC,SAAO,KAAK,CAAC,MAAM,CAGqB,GAFtC,SAAS,GAAC,MAAM,CAa5B;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,cAAc,EAHnC,MAGmC,GAFjC,MAAM,GAAC,SAAS,CAqF5B;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,QAAA,EAAE,OAAO,EAH1C,MAG0C,GAFxC,MAAM,CAkBlB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,QAAA,GAF7B,MAAM,CAgBlB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,KAAA,EAAE,OAAO,KAAA;;;;;;cAoGtD"}

package/types/lib/helpers/annotationFormatter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Format annotation properties as a markdown table for CycloneDX annotations.
+ *
+ * @param {{ name: string, value: string }[]} properties annotation properties
+ * @returns {string} markdown table text
+ */
+export declare function propertiesToMarkdownTable(properties: {
+    name: string;
+    value: string;
+}[]): string;
+/**
+ * Build production-ready markdown annotation text.
+ *
+ * @param {string} message leading message text
+ * @param {{ name: string, value: string }[]} properties annotation properties
+ * @param {string[]} [details] optional detail lines shown before the table
+ * @returns {string} annotation text
+ */
+export declare function buildAnnotationText(message: string, properties: {
+    name: string;
+    value: string;
+}[], details?: string[]): string;
+//# sourceMappingURL=annotationFormatter.d.ts.map

package/types/lib/helpers/annotationFormatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotationFormatter.d.ts","sourceRoot":"","sources":["../../../lib/helpers/annotationFormatter.js"],"names":[],"mappings":"AA0BA;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAHzC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAGU,GAFvC,MAAM,CA0BlB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EALhC,MAKgC,EAAE,UAAU,EAJ5C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAIa,EAAE,OAAO,AAH7D,CACA,EADQ,MAAM,EAGoD,GAFxD,MAAM,CAmBlB"}

package/types/lib/helpers/bomSigner.d.ts

@@ -0,0 +1,28 @@
+import crypto from "node:crypto";
+/**
+ * Recursively applies signatures to the BOM and its granular components.
+ *
+ * @param {Object} bomJson - CycloneDX BOM Object
+ * @param {Object} options - Signing options { privateKey, algorithm, mode, ... }
+ * @returns {Object} - Signed BOM Object
+ */
+export declare function signBom(bomJson: Object, options?: Object): Object;
+/**
+ * Verifies the integrity of a specific element node (e.g., BOM root, Component, Service, Annotation).
+ * Resolves standard JSF signatures, multisignature (signers), and chains.
+ *
+ * @param {Object} node - The BOM or granular object to verify
+ * @param {string|crypto.KeyObject} publicKey - The public key corresponding to the signature
+ * @returns {boolean|Object} - Signature block if signature is valid. False otherwise.
+ */
+export declare function verifyNode(node: Object, publicKey: string | crypto.KeyObject): boolean | Object;
+/**
+ * Verifies the integrity of a BOM's top-level signature, as well as nested components, services, and annotations.
+ * Returns true only if the root signature is valid AND all signed nested elements are valid.
+ *
+ * @param {Object} bom - CycloneDX BOM Object
+ * @param {string|crypto.KeyObject} publicKey - The public key corresponding to the signature
+ * @returns {boolean|Object} - Signature block if signature is valid. False otherwise.
+ */
+export declare function verifyBom(bom: Object, publicKey: string | crypto.KeyObject): boolean | Object;
+//# sourceMappingURL=bomSigner.d.ts.map

package/types/lib/helpers/bomSigner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bomSigner.d.ts","sourceRoot":"","sources":["../../../lib/helpers/bomSigner.js"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAC;AAiIjC;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAJpB,MAIoB,EAAE,OAAO,GAH7B,MAGkC,GAFhC,MAAM,CAkDlB;AAuDD;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAJpB,MAIoB,EAAE,SAAS,EAH/B,MAAM,GAAC,MAAM,CAAC,SAGiB,GAF7B,OAAO,GAAC,MAAM,CA0B1B;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAJlB,MAIkB,EAAE,SAAS,EAH7B,MAAM,GAAC,MAAM,CAAC,SAGe,GAF3B,OAAO,GAAC,MAAM,CAgC1B"}

package/types/lib/helpers/exportUtils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Normalize the requested export formats.
+ *
+ * @param {string|string[]|undefined|null} format Raw format value
+ * @returns {string[]} Normalized export formats
+ */
+export declare function normalizeOutputFormats(format: string | string[] | undefined | null): string[];
+/**
+ * Derive the SPDX output path from a base output path.
+ *
+ * @param {string} outputPath Output path
+ * @returns {string} SPDX output path
+ */
+export declare function deriveSpdxOutputPath(outputPath: string): string;
+/**
+ * Derive the CycloneDX output path from a base output path.
+ *
+ * @param {string} outputPath Output path
+ * @returns {string} CycloneDX output path
+ */
+export declare function deriveCycloneDxOutputPath(outputPath: string): string;
+/**
+ * Derive the output path for a CycloneDX BOM converted to another spec version.
+ *
+ * The spec version is inserted ahead of the existing extension so the source
+ * BOM is never overwritten, and the extension is preserved so a protobuf input
+ * keeps producing a protobuf-suffixed name.
+ *
+ * @param {string} inputPath Input BOM path
+ * @param {string} specVersion Target CycloneDX spec version
+ * @returns {string} Converted CycloneDX output path
+ */
+export declare function deriveSpecVersionOutputPath(inputPath: string, specVersion: string): string;
+/**
+ * Determine the final output plan for the requested export formats.
+ *
+ * @param {object} options CLI options
+ * @returns {{ formats: Set<string>, outputs: Record<string, string>, explicitFormat: boolean }} Output plan
+ */
+export declare function createOutputPlan(options: object): {
+    formats: Set<string>;
+    outputs: Record<string, string>;
+    explicitFormat: boolean;
+};
+/**
+ * Return the output directory for a planned export path.
+ *
+ * @param {string} outputPath Output path
+ * @returns {string} Output directory
+ */
+export declare function getOutputDirectory(outputPath: string): string;
+//# sourceMappingURL=exportUtils.d.ts.map

package/types/lib/helpers/exportUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exportUtils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/exportUtils.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAHlC,MAAM,GAAC,MAAM,EAAE,GAAC,SAAS,GAAC,IAGQ,GAFhC,MAAM,EAAE,CAoBpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAHpC,MAGoC,GAFlC,MAAM,CAyBlB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAHzC,MAGyC,GAFvC,MAAM,CAUlB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAJ1C,MAI0C,EAAE,WAAW,EAHvD,MAGuD,GAFrD,MAAM,CAiBlB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAH7B,MAG6B,GAF3B;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,cAAc,EAAE,OAAO,CAAA;CAAE,CAgC9F;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAHlC,MAGkC,GAFhC,MAAM,CAIlB"}

package/types/lib/helpers/remote/dependency-track.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Returns the Dependency-Track BOM API URL as a sanitized URL object.
+ *
+ * @param {string} serverUrl Dependency-Track server URL
+ * @returns {URL | undefined} API URL to submit BOM payload
+ */
+export declare function getDependencyTrackBomApiUrl(serverUrl: string): URL | undefined;
+/**
+ * Returns the Dependency-Track BOM API URL string.
+ *
+ * @param {string} serverUrl Dependency-Track server URL
+ * @returns {string | undefined} API URL to submit BOM payload
+ */
+export declare function getDependencyTrackBomUrl(serverUrl: string): string | undefined;
+/**
+ * Build the payload for Dependency-Track BOM submission.
+ *
+ * @param {Object} args CLI/server arguments
+ * @param {Object} bomContents BOM Json
+ * @returns {Object | undefined} payload object if project coordinates are valid
+ */
+export declare function buildDependencyTrackBomPayload(args: Object, bomContents: Object): Object | undefined;
+//# sourceMappingURL=dependency-track.d.ts.map

package/types/lib/helpers/remote/dependency-track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-track.d.ts","sourceRoot":"","sources":["../../../../lib/helpers/remote/dependency-track.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAH1C,MAG0C,GAFxC,GAAG,GAAG,SAAS,CAyB3B;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAHvC,MAGuC,GAFrC,MAAM,GAAG,SAAS,CAI9B;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAJxC,MAIwC,EAAE,WAAW,EAHrD,MAGqD,GAFnD,MAAM,GAAG,SAAS,CAkE9B"}

package/types/lib/helpers/versutils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts a package.json npm version specifier to a VERS format range.
+ *
+ * @param {string} versionString - The native npm semver string.
+ * @returns {string} The formatted vers:npm range string.
+ */
+export declare function toVersRange(versionString: string): string;
+//# sourceMappingURL=versutils.d.ts.map

package/types/lib/helpers/versutils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versutils.d.ts","sourceRoot":"","sources":["../../../lib/helpers/versutils.js"],"names":[],"mappings":"AAgBA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAH9B,MAG8B,GAF5B,MAAM,CAqLlB"}