import * as os from 'os';
import * as fs from 'fs';

declare const SeverityLevel: {
    readonly CRITICAL: "CRITICAL";
    readonly HIGH: "HIGH";
    readonly MEDIUM: "MEDIUM";
    readonly LOW: "LOW";
    readonly INFO: "INFO";
};
type Severity = typeof SeverityLevel[keyof typeof SeverityLevel];

interface Finding {
    id: string;
    severity: Severity;
    description: string;
    fixRecommendation?: string;
    fixable?: boolean;
    remediationConfidence?: number;
    dependencyResolution?: 'lockfile' | 'manifest-range';
}
/**
 * Single contract for package metadata gathered by scanners. Both the
 * supply-chain scanner's result and ServerScanResult.metadata use this,
 * so peer scanners never borrow each other's types.
 */
interface PackageMetadata {
    packageName?: string;
    version?: string;
    versionSource?: 'registry' | 'snapshot';
    license?: string;
    licenseVerified?: boolean;
    repositoryUrl?: string;
    author?: string;
    integrity?: string;
    source?: 'npm' | 'local' | 'unknown';
}
interface ServerScanResult {
    serverName: string;
    toolName: string;
    configPath: string;
    findings: Finding[];
    scanDurationMs: number;
    trustScore?: number;
    /** Original server connection details from MCP config */
    connection?: {
        command?: string;
        args?: string[];
        url?: string;
        type?: string;
        env?: string[];
    };
    metadata?: PackageMetadata;
}
interface ScanReport {
    results: ServerScanResult[];
    totalScanned: number;
    criticalCount: number;
    highCount: number;
    mediumCount: number;
    lowCount: number;
    infoCount: number;
    totalDurationMs: number;
    version?: string;
}

/**
 * Options accepted by runScan. Single source of truth: the CLI, the
 * library entry (src/lib.ts), and the runScan implementation all share
 * this type so the public API cannot drift from the implementation.
 */
interface ScanOptions {
    silent?: boolean;
    json?: boolean;
    verbose?: boolean;
    severity?: string;
    config?: string;
    version?: string;
    ugig?: boolean;
    ci?: boolean;
    sbom?: string;
    sarif?: string;
    policy?: string;
    offline?: boolean;
    submit?: boolean;
}

declare function runScan(options?: ScanOptions): Promise<ScanReport>;

declare class BaselineKeyError extends Error {
    constructor(message: string);
}

interface McpServerEntry {
    command?: string;
    args?: string[];
    url?: string;
    type?: string;
    env?: Record<string, string>;
    disabled?: boolean;
    description?: string;
    schema?: any;
}
interface DetectedTool {
    name: string;
    configPath: string;
    exists: boolean;
}
interface ResolvedServer extends McpServerEntry {
    name: string;
    toolName: string;
    configPath: string;
}

interface DetectorDependencies {
    fs: Pick<typeof fs, 'existsSync'>;
    os: Pick<typeof os, 'homedir' | 'platform'>;
    process: {
        cwd: () => string;
        env: NodeJS.ProcessEnv;
    };
}
declare function detectTools(dependencies: DetectorDependencies): Promise<DetectedTool[]>;

declare function generateHtmlReport(report: ScanReport): string;

interface SarifRule {
    id: string;
    name: string;
    shortDescription: {
        text: string;
    };
    fullDescription: {
        text: string;
    };
    helpUri: string;
    properties: {
        precision: string;
        problem: {
            severity: string;
        };
    };
}
interface SarifResult {
    ruleId: string;
    level: string;
    message: {
        text: string;
    };
    locations: Array<{
        physicalLocation: {
            artifactLocation: {
                uri: string;
                uriBaseId: string;
            };
            region: {
                startLine: number;
            };
        };
    }>;
}
declare function generateSarif(report: ScanReport): {
    $schema: string;
    version: string;
    runs: {
        tool: {
            driver: {
                name: string;
                fullName: string;
                version: string;
                informationUri: string;
                rules: SarifRule[];
            };
        };
        results: SarifResult[];
        originalUriBaseIds: {
            SRCROOT: {
                uri: string;
            };
        };
    }[];
};

interface CycloneDXComponent {
    type: string;
    name: string;
    version: string;
    bomRef: string;
    purl: string;
    description: string;
    licenses?: Array<{
        license: {
            id: string;
        };
    }>;
    author?: string;
    externalReferences?: Array<{
        type: string;
        url: string;
    }>;
    hashes?: Array<{
        alg: string;
        content: string;
    }>;
}
interface CycloneDXVulnerability {
    id: string;
    source: {
        name: string;
        url: string;
    };
    description: string;
    recommendation?: string;
    ratings: Array<{
        score: number;
        severity: string;
        method: string;
    }>;
    analysis: {
        state: string;
        detail: string;
    };
    affects: Array<{
        ref: string;
    }>;
}
interface CycloneDXBom {
    bomFormat: string;
    specVersion: string;
    serialNumber: string;
    version: number;
    metadata: {
        timestamp: string;
        tools: Array<{
            vendor: string;
            name: string;
            version: string;
        }>;
    };
    components: CycloneDXComponent[];
    vulnerabilities?: CycloneDXVulnerability[];
}
declare function generateSbom(report: ScanReport, options?: {
    includeFindings?: boolean;
}): Promise<CycloneDXBom>;
/**
 * Generates an SPDX 2.3 tag-value document from the scan report.
 */
declare function generateSpdx(report: ScanReport): string;

declare function scanRegistry(server: ResolvedServer, offline?: boolean): Promise<Finding[]>;

declare function scanTyposquat(server: ResolvedServer): Finding[];

/**
 * Deep audit of a package, either online or using a bundled snapshot.
 */
declare function scanPackageDeep(server: ResolvedServer, offline?: boolean): Promise<Finding[]>;

interface SupplyChainResult {
    findings: Finding[];
    trustScore: number;
    metadata?: PackageMetadata;
}
declare function scanSupplyChain(server: ResolvedServer, offline?: boolean): Promise<SupplyChainResult>;

/**
 * Scans a package's license for compliance risks.
 * @param metadata The metadata gathered from the supply chain scan.
 * @returns An array of findings related to license risk.
 */
declare function scanLicense(metadata: PackageMetadata | undefined): Finding[];

/**
 * Static analysis for reverse shells, eval() abuse, and data exfiltration.
 * Upgraded to include cross-origin exfiltration analysis.
 */
declare function scanAst(server: ResolvedServer, allowedDomains?: string[]): Finding[];

declare function scanSecrets(server: ResolvedServer): Finding[];

/**
 * Scanner for Tool Poisoning & Capability Injection attacks.
 * Detects patterns in tool descriptions and arguments that aim to influence model behavior maliciously.
 */
declare function scanToolPoisoning(server: ResolvedServer): Finding[];

declare function scanPromptInjection(server: ResolvedServer): Finding[];

declare function scanTransport(server: ResolvedServer, allowedDomains?: string[]): Finding[];

declare function scanEnvLeak(server: ResolvedServer, serverFilePath: string): Finding[];

declare function scanNetworkEgress(server: ResolvedServer): Finding[];

/**
 * Scan for potentially dangerous data flows in tool definitions.
 * Heuristically maps sources (FS, Env, DB) to sinks (Network, Process, Websocket).
 */
declare function scanDataFlow(server: ResolvedServer, allServers?: ResolvedServer[]): Finding[];

interface PackageJsonLike {
    dependencies?: Record<string, string>;
}
interface LockfileLike {
    dependencies?: Record<string, {
        version?: string;
    }>;
    packages?: Record<string, {
        version?: string;
    }>;
}
/**
 * Full dependency-CVE pass for one package: resolves the dependency tree,
 * batch-queries OSV, hydrates matched advisories, and confirms each hit
 * against the resolved version before reporting it (name-only matches are
 * downgraded to a single low-severity "unresolved" finding, same policy
 * as scanPackageDeep's own-package check).
 */
declare function scanDependencyCves(pkgJson: PackageJsonLike, lockfile?: LockfileLike | null): Promise<Finding[]>;

declare class PolicyError extends Error {
    constructor(message: string);
}

export { BaselineKeyError, type Finding, PolicyError, type ResolvedServer, type ScanOptions, type ScanReport, type ServerScanResult, detectTools, generateHtmlReport, generateSarif, generateSbom, generateSpdx, runScan, scanAst, scanDataFlow, scanDependencyCves, scanEnvLeak, scanLicense, scanNetworkEgress, scanPackageDeep, scanPromptInjection, scanRegistry, scanSecrets, scanSupplyChain, scanToolPoisoning, scanTransport, scanTyposquat };