/**
 * ModernBERT-base K=4 capability heads — SP-158, #81.
 *
 * Optional HyDRA-fidelity encoder path: ModernBERT-base ONNX with K=4 independent
 * sigmoid heads on the [CLS] token (reasoning, code_gen, tool_use, debugging).
 *
 * **When to enable K=4 (`hydra_heads: modernbert_k4`):** Prefer SP-115
 * `learned_projection` until offline calibration Top-1 error exceeds ~10%
 * (routing-roadmap.md §2 P3). The fourth debugging dimension adds matcher
 * fidelity for terminal/tool-loop workloads; wiring into shortfall is SP-159.
 *
 * Module only — matcher integration is SP-159.
 */
import { z } from 'zod';
/** ModernBERT-base ONNX artifact for @huggingface/transformers (768-dim [CLS]). */
export declare const MODERNBERT_ONNX_MODEL = "onnx-community/ModernBERT-base-ONNX";
export declare const MODERNBERT_CLS_DIM = 768;
export declare const MODERNBERT_K4_HEAD_COUNT = 4;
/** Recommended calibration Top-1 error threshold before enabling K=4 heads. */
export declare const MODERNBERT_K4_ENABLE_TOP1_ERROR_THRESHOLD = 0.1;
export declare const K4_CAPABILITY_DIMENSIONS: readonly ["reasoning", "code_gen", "tool_use", "debugging"];
export type K4CapabilityDimension = (typeof K4_CAPABILITY_DIMENSIONS)[number];
export interface K4CapabilityVector {
    readonly reasoning: number;
    readonly code_gen: number;
    readonly tool_use: number;
    readonly debugging: number;
}
export declare const DEFAULT_MODERNBERT_K4_HEADS_PATH: string;
export declare const ModernBertK4HeadWeightsSchema: z.ZodObject<{
    version: z.ZodLiteral<1>;
    cls_dim: z.ZodLiteral<768>;
    weights: z.ZodArray<z.ZodArray<z.ZodNumber>>;
    bias: z.ZodArray<z.ZodNumber>;
}, z.core.$strip>;
export interface ModernBertK4HeadWeights {
    readonly version: 1;
    readonly cls_dim: typeof MODERNBERT_CLS_DIM;
    readonly weights: readonly (readonly number[])[];
    readonly bias: readonly number[];
}
export interface LoadModernBertK4HeadWeightsOptions {
    readonly filePath?: string;
}
export declare class ModernBertK4HeadWeightsLoaderError extends Error {
    readonly name = "ModernBertK4HeadWeightsLoaderError";
    constructor(message: string, options?: {
        cause?: unknown;
    });
}
export declare function parseModernBertK4HeadWeightsJson(raw: string): ModernBertK4HeadWeights;
export declare function loadModernBertK4HeadWeights(options?: LoadModernBertK4HeadWeightsOptions): ModernBertK4HeadWeights | null;
export declare function resolveModernBertK4HeadWeights(options?: LoadModernBertK4HeadWeightsOptions): ModernBertK4HeadWeights | null;
/** Deterministic quarter-pooled [CLS] placeholder when learned head weights are absent. */
export declare function projectClsToK4CapabilitiesPlaceholder(clsEmbedding: Float32Array): K4CapabilityVector;
/** Apply K=4 independent sigmoid heads to a ModernBERT [CLS] embedding. */
export declare function projectClsToK4Capabilities(clsEmbedding: Float32Array, weights?: ModernBertK4HeadWeights | null): K4CapabilityVector;
/** Flat K=4 head output as a length-4 array (values in [0, 1]). */
export declare function k4CapabilityVectorToArray(vector: K4CapabilityVector): readonly number[];
export declare function validateK4CapabilityVector(vector: K4CapabilityVector): void;
export interface ModernBertHeadsPredictor {
    predictCapabilities(text: string): Promise<K4CapabilityVector>;
    usesLearnedHeads(): boolean;
    dispose(): Promise<void>;
}
export interface CreateModernBertHeadsPredictorOptions {
    readonly headWeightsPath?: string;
}
/**
 * Creates a predictor backed by ModernBERT-base ONNX [CLS] extraction plus
 * optional learned K=4 head weights.
 */
export declare function createModernBertHeadsPredictor(artifactCachePath: string, options?: CreateModernBertHeadsPredictorOptions): Promise<ModernBertHeadsPredictor>;
//# sourceMappingURL=modernbert-heads.d.ts.map