@soos-io/api-client/dist/services/AnalysisService.d.ts

This is the SOOS API Client for registered clients leveraging the various integrations to the SOOS platform. Register for a free trial today at https://app.soos.io/register

import { AttributionFileTypeEnum, AttributionFormatEnum, FileMatchTypeEnum, HashAlgorithmEnum } from "./../enums";
import SOOSAnalysisApiClient, { ICreateScanRequestContributingDeveloperAudit, ICreateScanResponse, IScanStatusResponse } from "../api/SOOSAnalysisApiClient";
import SOOSProjectsApiClient from "../api/SOOSProjectsApiClient";
import SOOSUserApiClient from "../api/SOOSUserApiClient";
import { IntegrationName, IntegrationType, ScanStatus, ScanType } from "../enums";
import FormData from "form-data";
import SOOSHooksApiClient from "../api/SOOSHooksApiClient";
import SOOSAttributionApiClient, { IAttributionStatusModel } from "../api/SOOSAttributionApiClient";
interface IGenerateAttributionOutputParams {
    clientId: string;
    projectHash: string;
    projectName: string;
    branchHash: string;
    analysisId: string;
    format: AttributionFormatEnum;
    fileType: AttributionFileTypeEnum;
    includeDependentProjects?: boolean;
    includeVulnerabilities?: boolean;
    includeOriginalSbom?: boolean;
    workingDirectory: string;
}
interface IWaitForAttributionToFinishParams {
    clientId: string;
    projectHash: string;
    branchHash: string;
    scanId: string;
    attributionId: string;
}
interface IManifestFile {
    packageManager: string;
    name: string;
    path: string;
}
interface ISoosFileHash {
    filename: string;
    path: string;
    digests: Array<ISoosDigest>;
}
interface ISoosDigest {
    hashAlgorithm: HashAlgorithmEnum;
    digest: string;
}
interface ISoosHashesManifest {
    packageManager: string;
    fileHashes: Array<ISoosFileHash>;
}
interface IStartScanParams {
    clientId: string;
    projectHash: string;
    analysisId: string;
    scanType: ScanType;
    scanUrl: string;
}
interface IWaitForScanToFinishParams {
    scanStatusUrl: string;
    scanUrl: string;
    scanType: ScanType;
    isFirstCheckComplete?: boolean;
}
interface ISetupScanParams {
    clientId: string;
    projectName: string;
    branchName: string | null;
    commitHash: string | null;
    buildVersion: string | null;
    buildUri: string | null;
    branchUri: string | null;
    integrationType: IntegrationType;
    operatingEnvironment: string;
    integrationName: IntegrationName;
    appVersion: string | null;
    scriptVersion: string | null;
    contributingDeveloperAudit?: ICreateScanRequestContributingDeveloperAudit[];
    scanType: ScanType;
    toolName?: string | null;
    toolVersion?: string | null;
    commandLine?: string | null;
    scanMode?: string | null;
}
interface IUpdateScanStatusParams {
    clientId: string;
    projectHash: string;
    branchHash: string;
    scanType: ScanType;
    analysisId: string;
    status: ScanStatus;
    message: string;
    scanStatusUrl?: string;
}
declare const GeneratedScanTypes: ScanType[];
declare class AnalysisService {
    analysisApiClient: SOOSAnalysisApiClient;
    attributionApiClient: SOOSAttributionApiClient;
    projectsApiClient: SOOSProjectsApiClient;
    userApiClient: SOOSUserApiClient;
    hooksApiClient: SOOSHooksApiClient;
    constructor(analysisApiClient: SOOSAnalysisApiClient, attributionApiClient: SOOSAttributionApiClient, projectsApiClient: SOOSProjectsApiClient, userApiClient: SOOSUserApiClient, hooksApiClient: SOOSHooksApiClient);
    static create(apiKey: string, apiURL: string): AnalysisService;
    private logStatusMessage;
    setupScan({ clientId, projectName, branchName, commitHash, buildVersion, buildUri, branchUri, integrationType, operatingEnvironment, integrationName, appVersion, scriptVersion, contributingDeveloperAudit, scanType, toolName, toolVersion, commandLine, scanMode, }: ISetupScanParams): Promise<ICreateScanResponse>;
    startScan({ clientId, projectHash, analysisId, scanType, }: IStartScanParams): Promise<void>;
    waitForScanToFinish({ scanStatusUrl, scanUrl, scanType, }: IWaitForScanToFinishParams): Promise<ScanStatus>;
    private getColorBySeverity;
    private getResetColor;
    getFinalScanStatusMessage(scanType: ScanType, scanStatus: IScanStatusResponse, scanUrl: string, colorize?: boolean | undefined): Array<string>;
    waitForAttributionToFinish({ clientId, projectHash, branchHash, scanId, attributionId, }: IWaitForAttributionToFinishParams): Promise<IAttributionStatusModel>;
    generateFormattedOutput({ clientId, projectHash, projectName, branchHash, analysisId, format, fileType, includeDependentProjects, includeVulnerabilities, includeOriginalSbom, workingDirectory, }: IGenerateAttributionOutputParams): Promise<void>;
    updateScanStatus({ clientId, projectHash, branchHash, scanType, analysisId, status, message, scanStatusUrl, }: IUpdateScanStatusParams): Promise<void>;
    findAnalysisFiles(scanType: ScanType, path: string, pattern: string, filesToExclude?: string[] | null, directoriesToExclude?: string[] | null, maxFiles?: number): Promise<{
        filePaths: string[];
        hasMoreThanMaximumFiles: boolean;
    }>;
    findManifestsAndHashableFiles({ clientId, projectHash, filesToExclude, directoriesToExclude, sourceCodePath, packageManagers, fileMatchType, }: {
        clientId: string;
        projectHash: string;
        filesToExclude: string[];
        directoriesToExclude: string[];
        sourceCodePath: string;
        packageManagers: string[];
        fileMatchType: FileMatchTypeEnum;
    }): Promise<{
        manifestFiles: IManifestFile[] | null;
        hashManifests: ISoosHashesManifest[] | null;
    }>;
    private searchForManifestFiles;
    private searchForHashableFiles;
    getAnalysisFilesAsFormData(analysisFilePaths: string[], workingDirectory: string): Promise<FormData>;
    addManifestFilesToScan({ clientId, projectHash, branchHash, analysisId, scanType, scanStatusUrl, manifestFiles, }: {
        clientId: string;
        projectHash: string;
        branchHash: string;
        analysisId: string;
        scanType: ScanType;
        scanStatusUrl: string;
        manifestFiles: Array<IManifestFile>;
    }): Promise<void>;
    private uploadManifestFiles;
}
export { GeneratedScanTypes, IManifestFile };
export default AnalysisService;