import { z } from 'zod';
export declare const WindtunnelLockSchema: z.ZodEffects<z.ZodObject<{
    schema: z.ZodLiteral<"windtunnel.lock.v1">;
    canonicalPath: z.ZodString;
    gate: z.ZodString;
    frozenAt: z.ZodOptional<z.ZodObject<{
        timestamp: z.ZodOptional<z.ZodString>;
        commit: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        commit?: string | undefined;
        timestamp?: string | undefined;
    }, {
        commit?: string | undefined;
        timestamp?: string | undefined;
    }>>;
    phase: z.ZodEnum<["harness", "certifying"]>;
    producerKind: z.ZodOptional<z.ZodEnum<["mined", "authored"]>>;
    authored: z.ZodOptional<z.ZodObject<{
        expectedSplitRef: z.ZodString;
    }, "strict", z.ZodTypeAny, {
        expectedSplitRef: string;
    }, {
        expectedSplitRef: string;
    }>>;
    corpus: z.ZodObject<{
        repo: z.ZodString;
        selectionRule: z.ZodObject<{
            state: z.ZodString;
            predicate: z.ZodString;
            window: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
                type: z.ZodLiteral<"all">;
            }, "strip", z.ZodTypeAny, {
                type: "all";
            }, {
                type: "all";
            }>, z.ZodObject<{
                type: z.ZodLiteral<"bounded">;
                n: z.ZodNumber;
            }, "strip", z.ZodTypeAny, {
                type: "bounded";
                n: number;
            }, {
                type: "bounded";
                n: number;
            }>]>;
            asOfCommit: z.ZodString;
            codePathClassifier: z.ZodOptional<z.ZodObject<{
                includeGlobs: z.ZodArray<z.ZodString, "many">;
                excludeGlobs: z.ZodArray<z.ZodString, "many">;
            }, "strip", z.ZodTypeAny, {
                includeGlobs: string[];
                excludeGlobs: string[];
            }, {
                includeGlobs: string[];
                excludeGlobs: string[];
            }>>;
            excludeRevertPairs: z.ZodDefault<z.ZodBoolean>;
            excludeBotPrs: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            excludeRevertPairs: boolean;
            excludeBotPrs: boolean;
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
        }, {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
            excludeRevertPairs?: boolean | undefined;
            excludeBotPrs?: boolean | undefined;
        }>;
        resolvedPrs: z.ZodArray<z.ZodObject<{
            pr: z.ZodNumber;
            mergeCommit: z.ZodString;
            baseSha: z.ZodString;
            headSha: z.ZodString;
            diffSha: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }, {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }>, "many">;
    }, "strip", z.ZodTypeAny, {
        repo: string;
        selectionRule: {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            excludeRevertPairs: boolean;
            excludeBotPrs: boolean;
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
        };
        resolvedPrs: {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }[];
    }, {
        repo: string;
        selectionRule: {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
            excludeRevertPairs?: boolean | undefined;
            excludeBotPrs?: boolean | undefined;
        };
        resolvedPrs: {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }[];
    }>;
    fpDefinition: z.ZodObject<{
        rubricRef: z.ZodString;
        groundTruthRef: z.ZodString;
        adjudicator: z.ZodString;
        precisionFloor: z.ZodLiteral<1>;
    }, "strip", z.ZodTypeAny, {
        rubricRef: string;
        groundTruthRef: string;
        adjudicator: string;
        precisionFloor: 1;
    }, {
        rubricRef: string;
        groundTruthRef: string;
        adjudicator: string;
        precisionFloor: 1;
    }>;
    controls: z.ZodObject<{
        positiveRef: z.ZodString;
        negativeRef: z.ZodString;
        integrity: z.ZodObject<{
            mechanism: z.ZodString;
            fixtureSha: z.ZodString;
            llmReplaySha: z.ZodOptional<z.ZodString>;
            prDiffsSha: z.ZodOptional<z.ZodString>;
            corpusDispositionsSha: z.ZodOptional<z.ZodString>;
            groundTruthSha: z.ZodOptional<z.ZodString>;
        }, "strip", z.ZodTypeAny, {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        }, {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        }>;
    }, "strip", z.ZodTypeAny, {
        positiveRef: string;
        negativeRef: string;
        integrity: {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        };
    }, {
        positiveRef: string;
        negativeRef: string;
        integrity: {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        };
    }>;
    cullRateThreshold: z.ZodNumber;
    exposureDenominator: z.ZodObject<{
        activeRulesEvaluated: z.ZodObject<{
            floor: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            floor: number;
        }, {
            floor: number;
        }>;
        filesTouchedInWindow: z.ZodObject<{
            floor: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            floor: number;
        }, {
            floor: number;
        }>;
        positiveControlsExercised: z.ZodObject<{
            floor: z.ZodNumber;
        }, "strip", z.ZodTypeAny, {
            floor: number;
        }, {
            floor: number;
        }>;
    }, "strip", z.ZodTypeAny, {
        activeRulesEvaluated: {
            floor: number;
        };
        filesTouchedInWindow: {
            floor: number;
        };
        positiveControlsExercised: {
            floor: number;
        };
    }, {
        activeRulesEvaluated: {
            floor: number;
        };
        filesTouchedInWindow: {
            floor: number;
        };
        positiveControlsExercised: {
            floor: number;
        };
    }>;
}, "strip", z.ZodTypeAny, {
    schema: "windtunnel.lock.v1";
    corpus: {
        repo: string;
        selectionRule: {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            excludeRevertPairs: boolean;
            excludeBotPrs: boolean;
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
        };
        resolvedPrs: {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }[];
    };
    gate: string;
    canonicalPath: string;
    phase: "harness" | "certifying";
    fpDefinition: {
        rubricRef: string;
        groundTruthRef: string;
        adjudicator: string;
        precisionFloor: 1;
    };
    controls: {
        positiveRef: string;
        negativeRef: string;
        integrity: {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        };
    };
    cullRateThreshold: number;
    exposureDenominator: {
        activeRulesEvaluated: {
            floor: number;
        };
        filesTouchedInWindow: {
            floor: number;
        };
        positiveControlsExercised: {
            floor: number;
        };
    };
    authored?: {
        expectedSplitRef: string;
    } | undefined;
    frozenAt?: {
        commit?: string | undefined;
        timestamp?: string | undefined;
    } | undefined;
    producerKind?: "mined" | "authored" | undefined;
}, {
    schema: "windtunnel.lock.v1";
    corpus: {
        repo: string;
        selectionRule: {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
            excludeRevertPairs?: boolean | undefined;
            excludeBotPrs?: boolean | undefined;
        };
        resolvedPrs: {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }[];
    };
    gate: string;
    canonicalPath: string;
    phase: "harness" | "certifying";
    fpDefinition: {
        rubricRef: string;
        groundTruthRef: string;
        adjudicator: string;
        precisionFloor: 1;
    };
    controls: {
        positiveRef: string;
        negativeRef: string;
        integrity: {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        };
    };
    cullRateThreshold: number;
    exposureDenominator: {
        activeRulesEvaluated: {
            floor: number;
        };
        filesTouchedInWindow: {
            floor: number;
        };
        positiveControlsExercised: {
            floor: number;
        };
    };
    authored?: {
        expectedSplitRef: string;
    } | undefined;
    frozenAt?: {
        commit?: string | undefined;
        timestamp?: string | undefined;
    } | undefined;
    producerKind?: "mined" | "authored" | undefined;
}>, {
    schema: "windtunnel.lock.v1";
    corpus: {
        repo: string;
        selectionRule: {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            excludeRevertPairs: boolean;
            excludeBotPrs: boolean;
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
        };
        resolvedPrs: {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }[];
    };
    gate: string;
    canonicalPath: string;
    phase: "harness" | "certifying";
    fpDefinition: {
        rubricRef: string;
        groundTruthRef: string;
        adjudicator: string;
        precisionFloor: 1;
    };
    controls: {
        positiveRef: string;
        negativeRef: string;
        integrity: {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        };
    };
    cullRateThreshold: number;
    exposureDenominator: {
        activeRulesEvaluated: {
            floor: number;
        };
        filesTouchedInWindow: {
            floor: number;
        };
        positiveControlsExercised: {
            floor: number;
        };
    };
    authored?: {
        expectedSplitRef: string;
    } | undefined;
    frozenAt?: {
        commit?: string | undefined;
        timestamp?: string | undefined;
    } | undefined;
    producerKind?: "mined" | "authored" | undefined;
}, {
    schema: "windtunnel.lock.v1";
    corpus: {
        repo: string;
        selectionRule: {
            state: string;
            asOfCommit: string;
            predicate: string;
            window: {
                type: "all";
            } | {
                type: "bounded";
                n: number;
            };
            codePathClassifier?: {
                includeGlobs: string[];
                excludeGlobs: string[];
            } | undefined;
            excludeRevertPairs?: boolean | undefined;
            excludeBotPrs?: boolean | undefined;
        };
        resolvedPrs: {
            pr: number;
            headSha: string;
            mergeCommit: string;
            baseSha: string;
            diffSha?: string | undefined;
        }[];
    };
    gate: string;
    canonicalPath: string;
    phase: "harness" | "certifying";
    fpDefinition: {
        rubricRef: string;
        groundTruthRef: string;
        adjudicator: string;
        precisionFloor: 1;
    };
    controls: {
        positiveRef: string;
        negativeRef: string;
        integrity: {
            mechanism: string;
            fixtureSha: string;
            llmReplaySha?: string | undefined;
            prDiffsSha?: string | undefined;
            corpusDispositionsSha?: string | undefined;
            groundTruthSha?: string | undefined;
        };
    };
    cullRateThreshold: number;
    exposureDenominator: {
        activeRulesEvaluated: {
            floor: number;
        };
        filesTouchedInWindow: {
            floor: number;
        };
        positiveControlsExercised: {
            floor: number;
        };
    };
    authored?: {
        expectedSplitRef: string;
    } | undefined;
    frozenAt?: {
        commit?: string | undefined;
        timestamp?: string | undefined;
    } | undefined;
    producerKind?: "mined" | "authored" | undefined;
}>;
export type WindtunnelLock = z.infer<typeof WindtunnelLockSchema>;
/**
 * Compute a content-based per-firing label id (A2).
 * Keyed on hash(ruleId + pr + filePath + normalizedMatchedLineText) to survive
 * line-drift without raw line-number anchoring.
 */
export declare function firingLabelId(ruleId: string, pr: number, filePath: string, normalizedMatchedLineText: string): string;
//# sourceMappingURL=windtunnel-lock.d.ts.map