import type { PolicyVerdict } from './policy.js';
import type { EvaluationMethod } from './execution-envelope.js';
export type { EvaluationMethod } from './execution-envelope.js';
export type ScopeInterpretation = 'exact' | 'glob' | 'hierarchical';
export type ContentHashAlgorithm = 'sha256';
export interface ContentHash {
    algorithm: ContentHashAlgorithm;
    hash: string;
    canonicalForm: string;
    /** Identity boundary: sorted list of top-level field names included in the hash.
     *  Part of the committed content — changing the boundary changes the hash.
     *  Enables portable identity: any engine can verify which fields define identity
     *  without depending on external spec projection rules. */
    identityBoundary?: string[];
}
export interface DecisionSemantics {
    structuralVerdict: PolicyVerdict;
    trustVerdict: PolicyVerdict | null;
    override?: {
        active: boolean;
        phase: string;
        wouldHaveBeen: PolicyVerdict;
    };
    finalVerdictRule: string;
    reproducibility: string;
}
export interface DecisionArtifact {
    artifactId: string;
    artifactType: 'decision';
    version: string;
    engine: string;
    timestamp: string;
    intent: {
        intentId: string;
        agentId: string;
        action: {
            type: string;
            target: string;
            scopeRequired: string;
        };
        contentHash: ContentHash;
    };
    evaluation: {
        verdict: PolicyVerdict;
        evaluationMethod: EvaluationMethod;
        principlesChecked: string[];
        evaluatorId: string;
        decisionId: string;
    };
    semantics: DecisionSemantics;
    proof: {
        intentSignature: string;
        decisionSignature: string;
        artifactSignature: string;
    };
}
export interface DecisionArtifactVerification {
    /** The conjunction of every property below. True only when the artifact is
     *  bound to the source intent and decision, both were signed by the trust
     *  anchors the caller supplied, and every projected value matches its
     *  source. Never true on the artifact's self-consistency alone. */
    valid: boolean;
    /** The artifact's content hash was recomputed from `originalIntent` and
     *  matched. An artifact carrying no content hash is not verifiable and
     *  reports false. */
    contentHashValid: boolean;
    /** `originalIntent.signature` verified under `keys.intentSignerPublicKey`
     *  — the caller's anchor, not the key the intent carries about itself. */
    intentSignatureValid: boolean;
    /** `originalDecision.signature` verified under
     *  `keys.decisionSignerPublicKey`, on the same terms. */
    decisionSignatureValid: boolean;
    /** The artifact envelope verified under `keys.artifactSignerPublicKey`. */
    artifactSignatureValid: boolean;
    /** `originalDecision.intentId === originalIntent.intentId`: the decision
     *  presented is a decision about the intent presented. */
    linkageValid: boolean;
    /** Every value the artifact projects from the intent or the decision —
     *  verdict, evaluator, decision id, principles, action, hashes and the two
     *  copied signature strings — equals its source. */
    projectionValid: boolean;
    errors: string[];
}
//# sourceMappingURL=decision-semantics.d.ts.map