import type { CapabilityEffect, CapabilityManifest } from "./types.js";
/**
 * Conservative compatibility check for the object-schema subset Capability currently uses most often.
 * `replacementInput` must accept every required field the original required without adding a new required field.
 * `replacementOutput` must preserve every output field the original guaranteed.
 */
export declare function assessContractSubstitution(original: CapabilityManifest, replacement: CapabilityManifest): {
    compatible: boolean;
    breaking: string[];
    reasons: string[];
};
export type SubstitutionTrust = {
    score?: number;
    packageIntegrity?: string;
    provenanceVerified?: boolean;
    registrySignatureVerified?: boolean;
};
export type SubstitutionCertificate = {
    accepted: boolean;
    original: {
        id: string;
        version: string;
    };
    replacement: {
        id: string;
        version: string;
    };
    authorityDelta: {
        removed: readonly CapabilityEffect[];
        added: readonly CapabilityEffect[];
    };
    behaviorRegressions: readonly string[];
    contractBreaking: readonly string[];
    trustRegression: boolean;
    reasons: readonly string[];
    certificate: string;
};
/**
 * Issues a deterministic certificate only when a replacement is contract-compatible,
 * does not expand authority, does not weaken declared behavioral guarantees, and does not lower trust.
 */
export declare function certifyCapabilitySubstitution(original: CapabilityManifest, replacement: CapabilityManifest, originalTrust?: SubstitutionTrust, replacementTrust?: SubstitutionTrust): SubstitutionCertificate;
export type EvolutionAssessment = {
    classification: "safe-patch" | "authority-reducing" | "review-required" | "breaking";
    semverRecommendation: "patch" | "minor" | "major";
    substitution: SubstitutionCertificate;
    changes: readonly string[];
};
/** Classifies a capability contract change using semantics that ordinary SemVer cannot see: effects and behavioral guarantees. */
export declare function assessCapabilityEvolution(previous: CapabilityManifest, next: CapabilityManifest): EvolutionAssessment;
export type DominanceCandidate = {
    manifest: CapabilityManifest;
    trustScore?: number;
    provenanceVerified?: boolean;
    registrySignatureVerified?: boolean;
};
export type DominanceResult = {
    frontier: readonly {
        id: string;
        version: string;
        risk: number;
        trust: number;
        deterministic: boolean;
        reversible: boolean;
    }[];
    dominated: readonly {
        id: string;
        version: string;
        dominatedBy: string;
    }[];
};
/** Returns the Pareto frontier for interchangeable candidates instead of collapsing safety/trust into one opaque score. */
export declare function resolveCapabilityDominance(candidates: readonly DominanceCandidate[]): DominanceResult;
//# sourceMappingURL=evolution.d.ts.map