import type { HsonSerializeInputOptions } from "../api/transform/serializers/serialize-hson.js";
import { type CanonicalHsonDifference } from "../core/canonical-hson-equal.js";
import { type TransformErrorDetails } from "../core/errors.js";
import type { HsonNode } from "../core/types.js";
export type TransformOracleClassification = "expected-rejection" | "unexpected-acceptance" | "unexpected-rejection" | "unexpected-error-class" | "canonical-divergence" | "input-mutation" | "nonconvergent-cycle" | "cross-runtime-divergence";
export type TransformOracleExpectedClassification = TransformOracleClassification | "success";
export type TransformOracleStage = "source-admission" | "tokenization" | "parsing" | "root-detachment" | "canonical-invariant-admission" | "serialization-admission" | "serialization" | "reparse" | "canonical-comparison" | "nonmutation" | "runtime-projection";
export type TransformOracleWitness = Readonly<{
    launcher: string;
    case: string;
    operation: string;
    ingress?: string;
    source?: string;
    graphFixture?: unknown;
    serializeOptions?: Readonly<{
        noBreak?: boolean;
        noQuid?: boolean;
    }>;
    expectedClassification: TransformOracleExpectedClassification;
    actualClassification: TransformOracleClassification;
    stage?: TransformOracleStage | string;
    firstCanonicalDifference?: CanonicalHsonDifference;
    structuredError?: TransformErrorDetails;
}>;
export declare class TransformOracleAssertionError extends Error {
    readonly classification: TransformOracleClassification;
    readonly witness: TransformOracleWitness;
    readonly witnessBody: string;
    constructor(classification: TransformOracleClassification, witness: TransformOracleWitness, cause?: unknown);
}
export declare function format_transform_oracle_witness(witness: TransformOracleWitness): string;
export declare function assert_canonical_oracle_graph_equal(input: Readonly<{
    launcher: string;
    caseId: string;
    operation: string;
    expected: HsonNode;
    actual: HsonNode;
    ingress?: string;
    source?: string;
    serializeOptions?: HsonSerializeInputOptions;
    classification?: "canonical-divergence" | "cross-runtime-divergence" | "input-mutation";
}>): void;
export type CanonicalClosureInput = Readonly<{
    launcher: string;
    caseId: string;
    ingress: "hson-source" | "canonical-node";
    source?: string;
    node?: HsonNode;
    expectedNode?: HsonNode;
    serializeOptions?: HsonSerializeInputOptions;
    cycles?: number;
    compareFluent?: boolean;
}>;
export type CanonicalClosureResult = Readonly<{
    semantic: HsonNode;
    serialized: string;
    reparsed: HsonNode;
}>;
export type CanonicalSerializedClosureInput = Readonly<{
    launcher: string;
    caseId: string;
    node: HsonNode;
    serialized: string;
    expectedNode?: HsonNode;
    ingress?: string;
    serializeOptions?: HsonSerializeInputOptions;
}>;
/** Assert closure for an already-produced serializer output. */
export declare function assertCanonicalSerializedClosure(input: CanonicalSerializedClosureInput): HsonNode;
/** Assert strict parse/serialize/reparse closure without comparison-time repair. */
export declare function assertCanonicalClosure(input: CanonicalClosureInput): CanonicalClosureResult;
export type CanonicalRejectionInput = Readonly<{
    launcher: string;
    caseId: string;
    operation: string;
    ingress?: string;
    source?: string;
    candidate?: HsonNode;
    expectedCode: string;
    expectedStage?: string;
    run: () => unknown;
    repetitions?: number;
}>;
/** Assert one stable, structured, operation-owned rejection. */
export declare function assertCanonicalRejection(input: CanonicalRejectionInput): Readonly<{
    details: TransformErrorDetails;
    witnessBody: string;
}>;
export declare function assertCanonicalRuntimeParity(input: Readonly<{
    launcher: string;
    caseId: string;
    operation: string;
    projections: readonly Readonly<{
        runtime: string;
        run: () => HsonNode;
    }>[];
}>): readonly HsonNode[];
/** Controlled cycle hook used to prove convergence diagnostics independently. */
export declare function assertCanonicalCycleConvergence(input: Readonly<{
    launcher: string;
    caseId: string;
    operation: string;
    initial: HsonNode;
    cycles: number;
    next: (current: HsonNode, cycle: number) => HsonNode;
}>): HsonNode;
export type TransformRegressionCase = Readonly<{
    kind: "valid-source-closure";
    caseId: string;
    source: string;
    serializeOptions?: HsonSerializeInputOptions;
}> | Readonly<{
    kind: "invalid-source-rejection";
    caseId: string;
    source: string;
    expectedCode: string;
    expectedStage?: string;
}> | Readonly<{
    kind: "valid-graph-serialization-closure";
    caseId: string;
    node: HsonNode;
    serializeOptions?: HsonSerializeInputOptions;
}> | Readonly<{
    kind: "invalid-graph-serialization-rejection";
    caseId: string;
    node: HsonNode;
    expectedCode: string;
    expectedStage?: string;
}> | Readonly<{
    kind: "cross-runtime-parity";
    caseId: string;
    fixture: HsonNode;
    runtimes: readonly string[];
}>;
//# sourceMappingURL=transform-test-oracle.d.ts.map