import { type ReadinessLevel, type ReadinessReport } from "./readiness.js";
import { type ExecutableSurfaceInventory } from "../executable-surface-inventory.js";
import type { ConfigOverrides } from "../config.js";
import type { AssetKind, AssetStatus, DependencyKind } from "../model.js";
import { type RepositorySnapshot } from "../repository-evidence.js";
import type { SecurityPolicyInventorySummary } from "../security-policy-inventory.js";
import type { SecurityPostureSummary } from "../security-posture.js";
import type { Diagnostic } from "../types/diagnostics.js";
import type { AssetOwnership } from "../types/governance.js";
export declare const REPOSITORY_CONTEXT_BOM_SCHEMA_VERSION: "renma.repository-context-bom.v3";
type BomFormat = "json" | "markdown";
type BomOutputMode = "default" | "omit_generated_at";
interface BomOptions {
    omitGeneratedAt?: boolean;
}
interface BomBuildOptions extends BomOptions {
    generatedAt?: Date | string;
    evaluationDate?: Date | string;
}
export interface BomReport {
    schemaVersion: typeof REPOSITORY_CONTEXT_BOM_SCHEMA_VERSION;
    generatedAt?: string;
    outputMode: BomOutputMode;
    generator: {
        name: "renma";
        version: string;
    };
    root: string;
    configPath?: string;
    scope: {
        type: "declared_repository_manifest";
        runtimeUsage: false;
        telemetryCollected: false;
    };
    summary: {
        scannedFileCount: number;
        assetCount: number;
        dependencyCount: number;
        resolvedDependencyCount: number;
        unresolvedDependencyCount: number;
        ownedAssetCount: number;
        unownedAssetCount: number;
        readinessScore: number;
        readinessLevel: ReadinessLevel;
        diagnosticCounts: {
            error: number;
            warning: number;
            info: number;
        };
    };
    assets: BomAsset[];
    dependencies: BomDependency[];
    readiness: {
        score: number;
        level: ReadinessLevel;
        checks: ReadinessReport["checks"];
        summary: Omit<ReadinessReport["summary"], "skillDiscovery">;
    };
    securityPosture: SecurityPostureSummary;
    securityPolicyInventory: SecurityPolicyInventorySummary;
    executableSurfaceInventory: ExecutableSurfaceInventory;
    diagnostics: Diagnostic[];
}
interface BomAsset {
    id: string;
    kind: AssetKind;
    sourcePath: string;
    contentHash: string;
    sizeBytes: number;
    contentClassification: "text" | "binary";
    markdownParserEligible: boolean;
    ownership: AssetOwnership;
    status?: AssetStatus;
    statusReason?: string;
    statusChangedAt?: string;
    version?: string;
    tags: string[];
    lifecycle?: BomAssetLifecycle;
    dependencies: BomAssetDependency[];
    dependents: BomAssetDependent[];
    diagnostics: Diagnostic[];
}
interface BomAssetLifecycle {
    status?: AssetStatus;
    statusReason?: string;
    statusChangedAt?: string;
    lastReviewedAt?: string;
    reviewCycle?: string;
    expiresAt?: string;
}
interface BomAssetDependency {
    kind: DependencyKind;
    to: string;
    resolved: boolean;
    targetId?: string;
    targetKind?: AssetKind;
    targetPath?: string;
}
interface BomAssetDependent {
    kind: DependencyKind;
    from: string;
    sourcePath: string;
}
interface BomDependency {
    from: string;
    to: string;
    kind: DependencyKind;
    sourcePath: string;
    resolved: boolean;
    targetId?: string;
    targetKind?: AssetKind;
    targetPath?: string;
}
export declare function runBomCommand(targetPath: string, options: {
    format: BomFormat;
    overrides?: ConfigOverrides;
    omitGeneratedAt?: boolean;
}): Promise<number>;
export declare function bom(targetPath: string, overrides?: ConfigOverrides, options?: BomOptions): Promise<BomReport>;
export declare function buildBomReport(snapshot: RepositorySnapshot, options?: BomBuildOptions): BomReport;
export declare function formatBomJson(report: BomReport): string;
export declare function formatBomMarkdown(report: BomReport): string;
export {};