import type { ConfigOverrides } from "../config.js";
import { type ExecutableSurfaceDependency } from "../executable-dependency-resolution.js";
import { EXECUTABLE_SURFACE_INVENTORY_SCHEMA, type ExecutableSurfaceEntry, type ExecutableSurfaceInvocation } from "../executable-surface-inventory.js";
import type { AssetStatus } from "../model.js";
import { type RepositorySnapshot } from "../repository-evidence.js";
import type { Diagnostic } from "../types/diagnostics.js";
export declare const EXPERIMENTAL_EXECUTION_CONTRACT_SCHEMA: "renma.experimental-execution-contract.v1";
export declare const EXECUTION_CONTRACT_EVIDENCE_DIGEST_SCOPE: "selected_execution_contract_evidence_v1";
interface ExecutionContractOptions {
    entrypoint: string;
    sourceRevision?: string;
}
export interface ExecutionContractReport {
    schemaVersion: typeof EXPERIMENTAL_EXECUTION_CONTRACT_SCHEMA;
    stability: "experimental";
    generator: {
        name: "renma";
        version: string;
    };
    scope: {
        type: "declared_execution_contract";
        evidenceKind: "static_repository_evidence";
        runtimeUsage: false;
        telemetryCollected: false;
        authorizationDecision: false;
    };
    sourceRevision?: {
        value: string;
        providedBy: "caller";
        verifiedByRenma: false;
    };
    evidenceDigest: {
        algorithm: "sha256";
        value: string;
        scope: typeof EXECUTION_CONTRACT_EVIDENCE_DIGEST_SCOPE;
        calculatedBy: "renma";
    };
    subject: ExecutionContractSubject;
    executableEvidence: {
        inventorySchema: typeof EXECUTABLE_SURFACE_INVENTORY_SCHEMA;
        surfaces: ExecutionContractSurface[];
        relationships: ExecutionContractRelationship[];
        structuralRelationships: ExecutionContractStructuralRelationship[];
        unresolvedEvidence: ExecutionContractEvidence[];
    };
    analysisBoundary: {
        kind: "bounded_static_analysis";
        coverage: {
            reachableRepositoryScriptCount: number;
            recognizedInvocationEvidenceCount: number;
            recognizedDependencyEvidenceCount: number;
            topologicalInvocationEvidenceCount: number;
            topologicalDependencyEvidenceCount: number;
            nonTopologicalEvidenceCount: number;
        };
        observations: {
            driftAssessmentPerformed: false;
            noUnresolvedStaticEvidenceObserved: boolean;
            runtimeOrUnsupportedBehaviorAbsenceProven: false;
        };
        limitations: string[];
    };
    diagnostics: Diagnostic[];
}
interface ExecutionContractSubject {
    id: string;
    kind: "skill";
    sourcePath: string;
    contentHash: string;
    status?: AssetStatus;
    statusReason?: string;
    statusChangedAt?: string;
}
interface ExecutionContractSurface {
    kind: "repository-script";
    sourcePath: string;
    scope: ExecutableSurfaceEntry["scope"];
    contentHash?: string;
    fingerprint: string;
    interpreterHints: string[];
    reachableFromSubject: boolean;
    minimumInvocationDepth?: number;
    inventoryDependencyEvidence: ExecutableSurfaceEntry["dependencyEvidence"];
}
interface ExecutionContractEndpoint {
    kind: "skill" | "repository-script";
    sourcePath: string;
    id?: string;
    contentHash?: string;
}
interface ExecutionContractRelationship {
    from: ExecutionContractEndpoint;
    to: ExecutionContractEndpoint & {
        kind: "repository-script";
    };
    relationship: "invokes";
    expectation: "possible";
    reachability: "direct" | "transitive";
    minimumTargetDepth: number;
    evidence: ExecutionContractEvidence[];
}
interface ExecutionContractStructuralRelationship {
    from: ExecutionContractEndpoint & {
        kind: "skill";
        id: string;
    };
    to: ExecutionContractEndpoint & {
        kind: "repository-script";
    };
    relationship: "contains";
    meaning: "structural_placement_only";
}
type ExecutionContractEvidence = ExecutionContractInvocationEvidence | ExecutionContractDependencyEvidence;
interface ExecutionContractInvocationEvidence {
    type: "invocation";
    sourcePath: string;
    line: number;
    snippet: string;
    launcher: ExecutableSurfaceInvocation["launcher"];
    rawTarget: string;
    normalizedTarget?: string;
    resolution: ExecutableSurfaceInvocation["resolution"];
    targetPathState?: ExecutableSurfaceInvocation["targetPathState"];
    occurrenceOrdinal: number;
}
interface ExecutionContractDependencyEvidence {
    type: "dependency";
    sourcePath: string;
    line: number;
    snippet: string;
    analyzer: ExecutableSurfaceDependency["analyzer"];
    relation: ExecutableSurfaceDependency["relation"];
    rawSpecifier: string;
    normalizedTargetCandidates: string[];
    normalizedTarget?: string;
    resolution: ExecutableSurfaceDependency["resolution"];
    targetPathState?: ExecutableSurfaceDependency["targetPathState"];
    occurrenceOrdinal: number;
}
export declare function runExecutionContractCommand(targetPath: string, options: ExecutionContractOptions & {
    overrides?: ConfigOverrides;
}): Promise<number>;
/** Pure deterministic projection over one already-collected repository snapshot. */
export declare function buildExecutionContract(snapshot: RepositorySnapshot, options: ExecutionContractOptions): ExecutionContractReport;
export declare function formatExecutionContractJson(report: ExecutionContractReport): string;
export {};