@cdxgen/cdxgen 0.0.1 → 13.0.1

package/types/lib/ecosystems/parsers-misc.d.ts

@@ -0,0 +1,450 @@
+/**
+ * Method to parse pubspec.lock files.
+ *
+ * @param pubLockData Contents of lock data
+ * @param lockFile Filename for setting evidence
+ *
+ * @returns {Object}
+ */
+export declare function parsePubLockData(pubLockData: any, lockFile: any): Object;
+/**
+ * Parses a Dart pub package's pubspec.yaml content and returns a list containing
+ * a single component object with name, description, version, homepage, and purl.
+ *
+ * @param {string} pubYamlData Raw YAML string contents of a pubspec.yaml file
+ * @returns {Object[]} List containing a single Dart package component object
+ */
+export declare function parsePubYamlData(pubYamlData: string): Object[];
+/**
+ * Parses Helm chart YAML data (Chart.yaml or repository index.yaml) and returns
+ * a list of Helm chart component objects including the chart itself and any
+ * declared dependencies or index entries.
+ *
+ * @param {string} helmData Raw YAML string contents of a Helm Chart.yaml or index.yaml file
+ * @returns {Object[]} List of Helm chart component objects with name, version, and optional homepage/repository
+ */
+export declare function parseHelmYamlData(helmData: string): Object[];
+/**
+ * Recursively walks a parsed YAML/JSON object structure to find container image
+ * references stored under common keys (image, repository, dockerImage, etc.) and
+ * appends discovered image and service entries to pkgList while tracking seen
+ * images in imgList to avoid duplicates.
+ *
+ * @param {Object|Array|string} keyValueObj The object, array, or string node to inspect
+ * @param {Object[]} pkgList Accumulator array that receives {image} and {service} entries
+ * @param {string[]} imgList Accumulator array of image name strings already seen
+ * @returns {string[]} The updated imgList
+ */
+export declare function recurseImageNameLookup(keyValueObj: Object | any[] | string, pkgList: Object[], imgList: string[]): string[];
+/**
+ * Parses the contents of a Dockerfile or Containerfile and returns a list of
+ * base image objects referenced by FROM instructions, substituting ARG default
+ * values where possible and skipping multi-stage build alias references.
+ *
+ * @param {string} fileContents Raw string contents of the Dockerfile/Containerfile
+ * @returns {Object[]} Array of objects with an image property for each unique base image
+ */
+export declare function parseContainerFile(fileContents: string): Object[];
+/**
+ * Parses a Bitbucket Pipelines YAML file and extracts all Docker image references
+ * used as build environments and pipe references (docker:// pipes are normalized).
+ *
+ * @param {string} fileContents Raw string contents of the bitbucket-pipelines.yml file
+ * @returns {Object[]} Array of objects with an image property for each referenced image or pipe
+ */
+export declare function parseBitbucketPipelinesFile(fileContents: string): Object[];
+/**
+ * Parses container specification data such as Docker Compose files, Kubernetes
+ * manifests, Tekton tasks, Skaffold configs, or Kustomize overlays (YAML, possibly
+ * multi-document) and returns a list of image, service, and OCI spec entries.
+ *
+ * @param {string} dcData Raw YAML string contents of the container spec file
+ * @returns {Object[]} Array of objects with image, service, or ociSpec properties
+ */
+export declare function parseContainerSpecData(dcData: string): Object[];
+/**
+ * Identifies the data flow direction of a Privado processing object based on its
+ * sinkId value: "write" sinks map to "inbound", "read" sinks to "outbound", and
+ * HTTP/gRPC sinks to "bi-directional".
+ *
+ * @param {Object} processingObj Privado processing object, expected to have a sinkId property
+ * @returns {string} Flow direction string: "inbound", "outbound", "bi-directional", or "unknown"
+ */
+export declare function identifyFlow(processingObj: Object): string;
+/**
+ * Parses a Privado data flow JSON file and returns a list of service objects
+ * enriched with data classifications, endpoints, trust-boundary flag, violations,
+ * and git metadata properties extracted from the scan result.
+ *
+ * @param {string} f Path to the Privado scan result JSON file
+ * @returns {Object[]} List of service component objects suitable for a SaaSBOM
+ */
+export declare function parsePrivadoFile(f: string): Object[];
+/**
+ * Parses an OpenAPI specification (JSON or YAML string) and returns a list
+ * containing a single service object with name, version, endpoints, and
+ * authentication flag derived from the spec's info, servers, paths, and
+ * securitySchemes sections.
+ *
+ * @param {string} oaData Raw JSON or YAML string contents of an OpenAPI specification
+ * @returns {Object[]} List containing a single service component object
+ */
+export declare function parseOpenapiSpecData(oaData: string): Object[];
+/**
+ * Parses Haskell Cabal freeze file content and extracts package name and version
+ * pairs from constraint lines (lines containing " ==").
+ *
+ * @param {string} cabalData Raw string contents of a Cabal freeze file
+ * @returns {Object[]} List of package objects with name and version fields
+ */
+export declare function parseCabalData(cabalData: string): Object[];
+/**
+ * Parses an Elixir mix.lock file and extracts Hex package name and version pairs
+ * from lines containing ":hex".
+ *
+ * @param {string} mixData Raw string contents of a mix.lock file
+ * @returns {Object[]} List of package objects with name and version fields
+ */
+export declare function parseMixLockData(mixData: string): Object[];
+/**
+ * Parses a GitHub Actions workflow YAML file and returns a list of action
+ * components for each step that uses an external action (steps with a "uses"
+ * field). Each component captures the action name, group, version/commit SHA,
+ * version pinning type, job context (runner, permissions, environment), and
+ * workflow-level metadata (triggers, concurrency, write permissions).
+ *
+ * @param {string} f Path to the GitHub Actions workflow YAML file
+ * @returns {Object[]} List of action component objects with purl, properties, and evidence
+ */
+export declare function parseGitHubWorkflowData(f: string): Object[];
+/**
+ * Parse Google Cloud Build YAML data and extract container image steps as packages.
+ *
+ * @param {string} cbwData Raw YAML string of a Cloud Build configuration file
+ * @returns {Object[]} Array of package objects parsed from the build steps
+ */
+export declare function parseCloudBuildData(cbwData: string): Object[];
+/**
+ * Parse Conan lock file data (conan.lock) and return the package list, dependency map,
+ * and parent component dependencies.
+ *
+ * Supports both the legacy `graph_lock.nodes` format (Conan 1.x) and the newer
+ * `requires` format (Conan 2.x).
+ *
+ * @param {string} conanLockData Raw JSON string of the Conan lock file
+ * @returns {{ pkgList: Object[], dependencies: Object, parentComponentDependencies: string[] }}
+ */
+export declare function parseConanLockData(conanLockData: string): {
+    pkgList: Object[];
+    dependencies: Object;
+    parentComponentDependencies: string[];
+};
+/**
+ * Parse a Conan conanfile.txt and extract required and optional packages.
+ *
+ * @param {string} conanData Raw text contents of a conanfile.txt
+ * @returns {Object[]} Array of package objects with purl, name, version, and scope
+ */
+export declare function parseConanData(conanData: string): Object[];
+/**
+ * Parse Collider lock file data (collider.lock) and return the package list and
+ * parent component dependencies.
+ *
+ * @param {string} colliderLockData Raw JSON string of the Collider lock file
+ * @param {string} lockFile Source lock file path
+ * @returns {{ pkgList: Object[], dependencies: Object, parentComponentDependencies: string[] }}
+ */
+export declare function parseColliderLockData(colliderLockData: string, lockFile: string): {
+    pkgList: Object[];
+    dependencies: Object;
+    parentComponentDependencies: string[];
+};
+/**
+ * Method to parse flake.nix files
+ *
+ * @param {String} flakeNixFile flake.nix file to parse
+ * @returns {Object} Object containing package information
+ */
+export declare function parseFlakeNix(flakeNixFile: string): Object;
+/**
+ * Method to parse flake.lock files
+ *
+ * @param {String} flakeLockFile flake.lock file to parse
+ * @returns {Object} Object containing locked dependency information
+ */
+export declare function parseFlakeLock(flakeLockFile: string): Object;
+/**
+ * Parse composer.json file
+ *
+ * @param {string} composerJsonFile composer.json file
+ *
+ * @returns {Object} Object with rootRequires and parent component
+ */
+export declare function parseComposerJson(composerJsonFile: string): Object;
+/**
+ * Parse composer lock file
+ *
+ * @param {string} pkgLockFile composer.lock file
+ * @param {array} rootRequires require section from composer.json
+ */
+export declare function parseComposerLock(pkgLockFile: string, rootRequires: array): never[] | {
+    pkgList: {
+        group: any;
+        name: any;
+        purl: any;
+        "bom-ref": string;
+        version: any;
+        repository: any;
+        license: any;
+        description: any;
+        scope: string;
+        properties: {
+            name: string;
+            value: string;
+        }[];
+        evidence: {
+            identity: {
+                field: string;
+                confidence: number;
+                methods: {
+                    technique: string;
+                    confidence: number;
+                    value: string;
+                }[];
+            };
+        };
+    }[];
+    dependenciesList: {
+        ref: string;
+        dependsOn: any[];
+    }[];
+    rootList: {
+        group: any;
+        name: any;
+        purl: any;
+        "bom-ref": string;
+        version: any;
+        repository: any;
+        license: any;
+        description: any;
+        scope: string;
+        properties: {
+            name: string;
+            value: string;
+        }[];
+        evidence: {
+            identity: {
+                field: string;
+                confidence: number;
+                methods: {
+                    technique: string;
+                    confidence: number;
+                    value: string;
+                }[];
+            };
+        };
+    }[];
+};
+/**
+ * Method to execute dpkg --listfiles to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
+export declare function executeDpkgList(pkgName: string): any;
+/**
+ * Method to execute dnf repoquery to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
+export declare function executeRpmList(pkgName: string): any;
+/**
+ * Method to execute apk -L info to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
+export declare function executeApkList(pkgName: string): any;
+/**
+ * Method to execute alpm -Ql to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
+export declare function executeAlpmList(pkgName: string): any;
+/**
+ * Method to execute equery files to determine the files provided by a given package
+ *
+ * @param {string} pkgName deb package name
+ * @returns
+ */
+export declare function executeEqueryList(pkgName: string): any;
+/**
+ * Parse swift dependency tree output json object
+ *
+ * @param {Array} pkgList Package list
+ * @param {Array} dependenciesList Dependencies
+ * @param {string} jsonObject Swift dependencies json object
+ * @param {string} pkgFile Package.swift file
+ */
+export declare function parseSwiftJsonTreeObject(pkgList: any[], dependenciesList: any[], jsonObject: string, pkgFile: string): any;
+/**
+ * Parse swift dependency tree output
+ * @param {string} rawOutput Swift dependencies json output
+ * @param {string} pkgFile Package.swift file
+ */
+export declare function parseSwiftJsonTree(rawOutput: string, pkgFile: string): {
+    rootList?: undefined;
+    pkgList?: undefined;
+    dependenciesList?: undefined;
+} | {
+    rootList: any[];
+    pkgList: any[];
+    dependenciesList: any[];
+};
+/**
+ * Parse swift package resolved file
+ * @param {string} resolvedFile Package.resolved file
+ */
+export declare function parseSwiftResolved(resolvedFile: string): {
+    name: any;
+    group: any;
+    version: any;
+    purl: string;
+    "bom-ref": string;
+    properties: {
+        name: string;
+        value: string;
+    }[];
+    evidence: {
+        identity: {
+            field: string;
+            confidence: number;
+            methods: {
+                technique: string;
+                confidence: number;
+                value: string;
+            }[];
+        };
+    };
+}[];
+/**
+ * Parse a CMake-generated dot/graphviz file and extract components and their dependency
+ * relationships.
+ *
+ * The first `digraph` entry becomes the parent component. Subsequent `node` entries
+ * with a `label` attribute are treated as direct dependencies, while commented
+ * `node -> node` relationships are used to construct the dependency graph.
+ *
+ * @param {string} dotFile Path to the CMake-generated dot file
+ * @param {string} pkgType PackageURL type to assign to extracted packages (e.g. `"generic"`)
+ * @param {Object} options CLI options; may contain `projectGroup`, `projectName`, and `projectVersion`
+ * @returns {{ parentComponent: Object, pkgList: Object[], dependenciesList: Object[] }}
+ */
+export declare function parseCmakeDotFile(dotFile: string, pkgType: string, options?: Object): {
+    parentComponent: Object;
+    pkgList: Object[];
+    dependenciesList: Object[];
+};
+/**
+ * Parse a CMake-like build file (CMakeLists.txt, meson.build, etc.) and extract the
+ * parent component and list of dependency packages.
+ *
+ * Handles `set`, `project`, `find_package`, `find_library`, `find_dependency`,
+ * `find_file`, `FetchContent_MakeAvailable`, and `dependency()` directives.
+ * Uses the MesonWrapDB to improve name resolution confidence.
+ *
+ * @param {string} cmakeListFile Path to the CMake-like build file
+ * @param {string} pkgType PackageURL type to assign to extracted packages (e.g. `"generic"`)
+ * @param {Object} options CLI options; may contain `projectGroup`, `projectName`, and `projectVersion`
+ * @returns {{ parentComponent: Object, pkgList: Object[] }}
+ */
+export declare function parseCmakeLikeFile(cmakeListFile: string, pkgType: string, options?: Object): {
+    parentComponent: Object;
+    pkgList: Object[];
+};
+/**
+ * Parse an atom C/C++ usage-slice report into per-file package usage data.
+ *
+ * Walks the `objectSlices` of an atom report, collecting resolved method names
+ * and full names per source file while skipping include globals and compiler
+ * internals.
+ *
+ * @param {object} sliceData Parsed atom usage-slice report.
+ * @returns {Object<string, Set<string>>|undefined} Map of file name to the set
+ *   of used symbols, or undefined when sliceData is empty.
+ */
+export declare function parseCUsageSlice(sliceData: object): Record<string, Set<string>> | undefined;
+/**
+ * Function to parse the .d make files
+ *
+ * @param {String} dfile .d file path
+ *
+ * @returns {Object} pkgFilesMap Object with package name and list of files
+ */
+export declare function parseMakeDFile(dfile: string): Object;
+/**
+ * Parse the contents of a 'Podfile.lock'
+ *
+ * @param {Object} podfileLock The content of the podfile.lock as an Object
+ * @param {String} projectPath The path to the project root
+ * @returns {Map} Map of all dependencies with their direct dependencies
+ */
+export declare function parsePodfileLock(podfileLock: Object, projectPath: string): Map<any, any>;
+/**
+ * Parse all targets and their direct dependencies from the 'Podfile'
+ *
+ * @param {Object} target A JSON-object representing a target
+ * @param {Map} allDependencies The map containing all parsed direct dependencies for a target
+ * @param {String} [prefix=undefined] Prefix to add to the targets name
+ */
+export declare function parsePodfileTargets(target: Object, allDependencies: Map<any, any>, prefix?: string): void;
+/**
+ * Parse a single line representing a dependency
+ *
+ * @param {String} dependencyLine The line that should be parsed as a dependency
+ * @param {boolean} [parseVersion=true] Include parsing the version of the dependency
+ * @returns {Object} Object representing a dependency
+ */
+export declare function parseCocoaDependency(dependencyLine: string, parseVersion?: boolean): Object;
+/**
+ * Execute the 'pod'-command with parameters
+ *
+ * @param {String[]} parameters The parameters for the command
+ * @param {String} path The path where the command should be executed
+ * @param {Object} options CLI options
+ * @returns {Object} The result of running the command
+ */
+export declare function executePodCommand(parameters: string[], path: string, options: Object): Object;
+/**
+ * Method that handles object creation for cocoa pods.
+ *
+ * @param {Object} dependency The dependency that is to be transformed into an SBOM object
+ * @param {Object} options CLI options
+ * @param {String} [type="library"] The type of Object to create
+ * @returns {Object} An object representing the pod in SBOM-format
+ */
+export declare function buildObjectForCocoaPod(dependency: Object, options: Object, type?: string): Object;
+/**
+ * Discard prefetched podspecs. Tests only.
+ */
+export declare function resetCocoaPodspecPrefetch(): void;
+/**
+ * Prefetch the remote podspecs a full CocoaPods scan is about to read.
+ *
+ * The probe is speculative — up to four URLs per pod — so batching all of them
+ * at once would issue requests the serial path never makes: a pod whose podspec
+ * sits on `main` is one request there and would be four here. Instead each
+ * candidate position is its own round, and a round carries only the pods that
+ * every earlier round missed. That is the same set of requests the serial path
+ * makes, in the same order of preference, with the pods within a round
+ * overlapped rather than queued. Rounds are bounded at four however many pods
+ * there are.
+ *
+ * @param {Array<Object>} dependencies Pod metadata objects, each optionally
+ *   carrying a `cdx:pods:podspecLocation` property.
+ * @returns {Promise<void>}
+ */
+export declare function prefetchCocoaPodspecs(dependencies: Array<Object>): Promise<void>;
+//# sourceMappingURL=parsers-misc.d.ts.map

package/types/lib/ecosystems/parsers-misc.d.ts.map

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

package/types/lib/ecosystems/parsers-python.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Method to parse python requires_dist attribute found in pypi setup.py
+ *
+ * @param {String} dist_string string
+ */
+export declare function parsePyRequiresDist(dist_string: string): {
+    name: string;
+    version: string;
+} | undefined;
+/**
+ * Method to parse pipfile.lock data
+ *
+ * @param {Object} lockData JSON data from Pipfile.lock
+ */
+export declare function parsePiplockData(lockData: Object): Promise<any[]>;
+/**
+ * Append a deduplicated name/value property to a component's properties array.
+ *
+ * @param {object} component Component to mutate.
+ * @param {string} name Property name.
+ * @param {string} value Property value.
+ * @returns {void}
+ */
+export declare function addComponentProperty(component: object, name: string, value: string): void;
+/**
+ * Method to parse python pyproject.toml file
+ *
+ * @param {string} tomlFile pyproject.toml file
+ * @returns {Object} Object with parent component, root dependencies, and metadata.
+ */
+export declare function parsePyProjectTomlFile(tomlFile: string): Object;
+/**
+ * Derive a file name for a file entry of a python lock file.
+ *
+ *  - poetry.lock `[metadata.files]` entries carry a `file` key.
+ *  - pdm.lock `[metadata.files]` entries carry a `url` key (no `file`).
+ *  - pylock.toml / uv.lock artifacts can carry an explicit `name`, a local
+ *    `path`, and/or a `url`.
+ *
+ * @param {object} fileEntry A single lock-file file entry.
+ * @returns {string | undefined} The derived file name, or undefined when none can be derived.
+ */
+export declare function derivePythonLockMetadataFileName(fileEntry: object): string | undefined;
+/**
+ * Method to parse python lock files such as poetry.lock, pdm.lock, uv.lock, and pylock.toml.
+ *
+ * @param {string} lockData Raw TOML text from poetry.lock, pdm.lock, uv.lock, or pylock.toml
+ * @param {string} lockFile Lock file name for evidence
+ * @param {string} pyProjectFile pyproject.toml file
+ */
+export declare function parsePyLockData(lockData: string, lockFile: string, pyProjectFile: string): Promise<{
+    pkgList: any[];
+    dependenciesList: any[];
+    parentComponent?: undefined;
+    rootList?: undefined;
+    pyLockProperties?: undefined;
+    workspaceWarningShown?: undefined;
+} | {
+    parentComponent: any;
+    pkgList: any[];
+    rootList: {
+        name: any;
+        version: any;
+        description: any;
+        properties: never[];
+    }[];
+    dependenciesList: {
+        ref: string;
+        dependsOn: any[];
+    }[];
+    pyLockProperties: any[];
+    workspaceWarningShown: boolean;
+}>;
+/**
+ * Method to parse requirements.txt file. This must be replaced with atom parsedeps.
+ *
+ * @param {String} reqFile Requirements.txt file
+ * @param {Boolean} fetchDepsInfo Fetch dependencies info from pypi
+ *
+ * @returns {Promise[Array<Object>]} List of direct dependencies from the requirements file
+ */
+export declare function parseReqFile(reqFile: string, fetchDepsInfo?: boolean): any;
+/**
+ * Parse environment markers into structured format
+ *
+ * @param {String} markersStr Raw markers string
+ * @returns {Array<Object>} Structured markers array
+ */
+export declare function parseReqEnvMarkers(markersStr: string): Array<Object>;
+/**
+ * Method to parse setup.py data
+ *
+ * @param {Object} setupPyData Contents of setup.py
+ */
+export declare function parseSetupPyFile(setupPyData: Object): Promise<Object[]>;
+/**
+ * Method to parse pixi.lock data
+ *
+ * @param {String} pixiLockFileName  pixi.lock file name
+ * @param {String} path File path
+ */
+export declare function parsePixiLockFile(pixiLockFileName: string, path: string): {
+    pkgList: any;
+    formulationList: any[];
+    rootList: any[];
+    dependenciesList: {
+        ref: string;
+        dependsOn: any[];
+    }[];
+    frozen: boolean;
+};
+/**
+ * Method to parse pixi.toml file
+ *
+ * @param {String} pixiToml
+ */
+export declare function parsePixiTomlFile(pixiToml: string): {};
+/**
+ * Method to run cli command `pixi install`
+ *
+ *
+ */
+export declare function generatePixiLockFile(_path: any): void;
+/**
+ * Parse a Mojo `mojoproject.toml` manifest.
+ *
+ * Mojo projects are pixi-managed, so conda and PyPI dependencies pulled through
+ * pixi.lock already keep their correct registered types via the pixi path.
+ * Only Mojo's *own* packages — declared in `mojoproject.toml` — need special
+ * handling: `mojo` is not a registered purl type, so each is emitted as
+ * `pkg:generic/...` with a `cdx:purl:proposedType=mojo` property.
+ *
+ * The manifest is TOML. The `[project]` table carries the project's name and
+ * version; `[dependencies]` maps dependency names to version specifiers. A
+ * declared version range (e.g. `==0.1.0`, `>=0.2`) is normalised to its
+ * concrete version when one is present, otherwise the version is omitted.
+ *
+ * @param {string} mojoProjectFile Path to `mojoproject.toml`
+ * @returns {{ pkgList: object[], parentComponent: object }}
+ */
+export declare function parseMojoProject(mojoProjectFile: string): {
+    pkgList: object[];
+    parentComponent: object;
+};
+//# sourceMappingURL=parsers-python.d.ts.map

package/types/lib/ecosystems/parsers-python.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-python.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-python.js"],"names":[],"mappings":"AA6BA;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,QAAA;;;cAqB9C;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAFpC,MAEoC,kBAe9C;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EALnC,MAKmC,EAAE,IAAI,EAJzC,MAIyC,EAAE,KAAK,EAHhD,MAGgD,GAF9C,IAAI,CAkBhB;AAmMD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAHpC,MAGoC,GAFlC,MAAM,CAuRlB;AAqFD;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAH/C,MAG+C,GAF7C,MAAM,GAAG,SAAS,CA2C9B;AAiBD;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAJnC,MAImC,EAAE,QAAQ,EAH7C,MAG6C,EAAE,aAAa,EAF5D,MAE4D;;;;;;;;;;;;;;;;;;;;;;GAijBtE;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAAC,OAAO,QAAA,EAAE,aAAa,UAAQ,OAEhE;AA+RD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,QAAA,GAFhC,KAAK,CAAC,MAAM,CAAC,CAmCzB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,WAAW,EAFvC,MAEuC,qBAqBjD;AA6CD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,gBAAgB,QAAA,EAAE,IAAI,QAAA;;;;;;;;;EAkLvD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,QAAA,MAqBzC;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,KAAA,QAkBzC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,eAAe,EAHrC,MAGqC,GAFnC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAE,CA8C1D"}

package/types/lib/ecosystems/parsers-rust.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Method to parse cargo.toml data
+ *
+ * The component described by a [package] section will be put at the front of
+ * the list, regardless of if [package] appears before or after
+ * [dependencies]. Found dependencies will be placed at the back of the
+ * list.
+ *
+ * The Cargo documentation specifies that the [package] section should appear
+ * first as a convention, but it is not enforced.
+ * https://doc.rust-lang.org/stable/style-guide/cargo.html#formatting-conventions
+ *
+ * @param {String} cargoTomlFile cargo.toml file
+ * @param {boolean} simple Return a simpler representation of the component by skipping extended attributes and license fetch.
+ * @param {Object} pkgFilesMap Object with package name and list of files
+ *
+ * @returns {Array} Package list
+ */
+export declare function parseCargoTomlData(cargoTomlFile: string, simple?: boolean, pkgFilesMap?: Object, context?: {}): any[];
+/**
+ * Parse a Cargo.lock file to find components within the Rust project.
+ *
+ * @param {String} cargoLockFile A path to a Cargo.lock file. The Cargo.lock-file path may be used as information for extended attributes, such as manifest based evidence.
+ * @param {boolean} simple Return a simpler representation of the component by skipping extended attributes and license fetch.
+ * @param {Object} pkgFilesMap Object with package name and list of files
+ *
+ * @returns {Array} A list of the project's components as described by the Cargo.lock-file.
+ */
+export declare function parseCargoData(cargoLockFile: string, simple?: boolean, pkgFilesMap?: Object): any[];
+/**
+ * Build a Cargo dependency graph from manifest relationships so workspace roots
+ * and member-to-member links can complement lockfile-derived dependency data.
+ *
+ * @param {string} cargoTomlFile Cargo.toml path
+ * @param {object} [context] manifest graph context
+ * @returns {object[]} Cargo dependency relationships
+ */
+export declare function parseCargoManifestDependencyData(cargoTomlFile: string, context?: object): object[];
+/**
+ * Parses a Cargo.lock file's TOML data and returns a flat dependency graph as an
+ * array of objects mapping each package purl to the purls it directly depends on.
+ *
+ * @param {string} cargoLockData Raw TOML string contents of a Cargo.lock file
+ * @returns {Object[]} Array of dependency relationship objects with ref and dependsOn fields
+ */
+export declare function parseCargoDependencyData(cargoLockData: string): Object[];
+/**
+ * Parses tab-separated cargo-auditable binary metadata output and returns a list
+ * of Rust package components. Optionally fetches crates.io metadata when
+ * FETCH_LICENSE is enabled.
+ *
+ * @param {string} cargoData Tab-separated string output from cargo-auditable or similar tool
+ * @returns {Promise<Object[]>} List of Rust package component objects with group, name, and version
+ */
+export declare function parseCargoAuditableData(cargoData: string): Promise<Object[]>;
+//# sourceMappingURL=parsers-rust.d.ts.map

package/types/lib/ecosystems/parsers-rust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsers-rust.d.ts","sourceRoot":"","sources":["../../../lib/ecosystems/parsers-rust.js"],"names":[],"mappings":"AA6mBA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,kBAAkB,CACtC,aAAa,QAAA,EACb,MAAM,GAPG,OAOK,EACd,WAAW,GAPF,MAOO,EAChB,OAAO,KAAK,SAuQb;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,aAAa,QAAA,EACb,MAAM,GAPG,OAOK,EACd,WAAW,GAPF,MAOO,SA8FjB;AAgCD;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAAC,aAAa,EAJnD,MAImD,EAAE,OAAO,AAHpE,CACA,EADQ,MAGiE,GAF/D,MAAM,EAAE,CAsIpB;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,aAAa,EAH3C,MAG2C,GAFzC,MAAM,EAAE,CAgEpB;AAED;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAAC,SAAS,EAH5C,MAG4C,GAF1C,OAAO,CAAC,MAAM,EAAE,CAAC,CA4B7B"}