/**
 * ASI-04 (OWASP Agentic Top 10) — Agentic Supply Chain: AI Bill of Materials.
 *
 * Microsoft AGT parity for the supply-chain gap. The existing SupplyChain module
 * audits npm dependencies; this produces the AI-BOM — a structured, tamper-evident
 * inventory of everything that composes an agent (its models, tools, MCP servers,
 * compliance packs, and dependencies) anchored by a `bomHash`, plus a minimal
 * SLSA-style provenance statement that binds that hash as its subject. A relying
 * org verifies the AI-BOM to trust the agent's supply chain.
 *
 * Invariants: pure in-process compute (I-10). `verifyAiBom` NEVER throws (I-2/I-3).
 *
 * @connexum/ai-governance
 */
export type AiBomComponentType = 'model' | 'tool' | 'mcp-server' | 'compliance-pack' | 'dependency';
export interface AiBomComponent {
    type: AiBomComponentType;
    /** Stable identifier within its type (model id, tool name, pack id, etc.). */
    id: string;
    name?: string;
    version?: string;
    /** Provider / vendor / supplier. */
    supplier?: string;
    /** Integrity hash of the component artifact, when known. */
    hash?: string;
}
export interface AiBom {
    bomFormat: 'connexum-ai-bom';
    specVersion: '1.0';
    agentId: string;
    generatedAt: string;
    components: AiBomComponent[];
    /** SHA-256 hex over the canonical JSON of the (sorted) components. */
    bomHash: string;
}
export interface AiBomInput {
    agentId: string;
    models?: Array<{
        id: string;
        provider?: string;
        version?: string;
        hash?: string;
    }>;
    tools?: string[];
    mcpServers?: string[];
    compliancePacks?: string[];
    dependencies?: Array<{
        name: string;
        version?: string;
        hash?: string;
    }>;
    /** Override the generation timestamp (default now). */
    generatedAt?: string;
}
export declare function canonicalBomJson(value: unknown): string;
/** Build the AI-BOM for an agent from its composed parts. */
export declare function generateAiBom(input: AiBomInput): AiBom;
/**
 * Verify an AI-BOM: recompute the hash over its components and compare. NEVER
 * throws — malformed input returns false.
 */
export declare function verifyAiBom(bom: AiBom): boolean;
export interface SlsaProvenance {
    _type: 'https://in-toto.io/Statement/v1';
    predicateType: 'https://slsa.dev/provenance/v1';
    subject: Array<{
        name: string;
        digest: {
            sha256: string;
        };
    }>;
    predicate: {
        buildType: string;
        builder: {
            id: string;
        };
        metadata: {
            invocationId: string;
            startedOn: string;
        };
    };
}
/**
 * Produce a minimal SLSA provenance statement binding the AI-BOM's `bomHash` as
 * the signed subject. A registration pipeline emits this so a relying org can
 * verify WHO built the agent's supply-chain inventory and WHAT it covered.
 */
export declare function generateSlsaProvenance(bom: AiBom, opts: {
    builder: string;
    buildType: string;
    invocationId?: string;
}): SlsaProvenance;
//# sourceMappingURL=ai-bom.d.ts.map