import type { ClubSelection, ShotResult, HazardType, ConditionType, SpecialPlay, MissDirection, ScoreLabel, SprintType, TrainingType, NutritionCategory } from './types.js';
/** Display names for club selections (approach complexity) */
export type ClubTerms = Record<ClubSelection, string>;
/** Display names for shot results (ticket outcomes) */
export type ShotResultTerms = Record<ShotResult, string>;
/** Display names for hazard types */
export type HazardTerms = Record<HazardType, string>;
/** Display names for external conditions */
export type ConditionTerms = Record<ConditionType, string>;
/** Display names for special plays */
export type SpecialPlayTerms = Record<SpecialPlay, string>;
/** Display names for miss directions */
export type MissDirectionTerms = Record<MissDirection, string>;
/** Display names for score labels */
export type ScoreLabelTerms = Record<ScoreLabel, string>;
/** Display names for sprint types */
export type SprintTypeTerms = Record<SprintType, string>;
/** Display names for training types */
export type TrainingTypeTerms = Record<TrainingType, string>;
/** Display names for nutrition categories */
export type NutritionTerms = Record<NutritionCategory, string>;
/** Metaphor-specific vocabulary for framework concepts */
export interface MetaphorVocabulary {
    /** What a sprint is called (e.g., "hole", "set", "inning") */
    sprint: string;
    /** What a ticket is called (e.g., "shot", "point", "at-bat") */
    ticket: string;
    /** What the scorecard is called (e.g., "scorecard", "match report") */
    scorecard: string;
    /** What the handicap card is called (e.g., "handicap card", "player stats") */
    handicapCard: string;
    /** What the briefing is called (e.g., "pre-round briefing", "pre-match scouting") */
    briefing: string;
    /** What a perfect score is called (e.g., "hole-in-one", "ace") */
    perfectScore: string;
    /** What par means (e.g., "par", "expected", "baseline") */
    onTarget: string;
    /** What the review is called (e.g., "19th hole", "post-match") */
    review: string;
}
/** A complete metaphor definition — all display terms for SLOPE output */
export interface MetaphorDefinition {
    /** Unique identifier (e.g., "golf", "tennis", "gaming") */
    id: string;
    /** Human-readable name (e.g., "Golf", "Tennis", "Gaming") */
    name: string;
    /** Brief description of the metaphor */
    description: string;
    /** Framework vocabulary */
    vocabulary: MetaphorVocabulary;
    /** Term maps for all enum types */
    clubs: ClubTerms;
    shotResults: ShotResultTerms;
    hazards: HazardTerms;
    conditions: ConditionTerms;
    specialPlays: SpecialPlayTerms;
    missDirections: MissDirectionTerms;
    scoreLabels: ScoreLabelTerms;
    sprintTypes: SprintTypeTerms;
    trainingTypes: TrainingTypeTerms;
    nutrition: NutritionTerms;
}
/** Register a metaphor definition */
export declare function registerMetaphor(metaphor: MetaphorDefinition): void;
/** Get a metaphor by ID. Returns the golf metaphor as fallback if not found. */
export declare function getMetaphor(id: string): MetaphorDefinition;
/** List all registered metaphors */
export declare function listMetaphors(): MetaphorDefinition[];
/** Check if a metaphor ID is registered */
export declare function hasMetaphor(id: string): boolean;
/** Schema describing all required keys for each MetaphorDefinition category. Agents use this to generate valid custom metaphors. */
export declare const METAPHOR_SCHEMA: {
    vocabulary: readonly ["sprint", "ticket", "scorecard", "handicapCard", "briefing", "perfectScore", "onTarget", "review"];
    clubs: ClubSelection[];
    shotResults: ShotResult[];
    hazards: HazardType[];
    conditions: ConditionType[];
    specialPlays: SpecialPlay[];
    missDirections: MissDirection[];
    scoreLabels: ScoreLabel[];
    sprintTypes: SprintType[];
    trainingTypes: TrainingType[];
    nutrition: NutritionCategory[];
};
/** Validate that a metaphor definition covers every required term */
export declare function validateMetaphor(metaphor: MetaphorDefinition): string[];
//# sourceMappingURL=metaphor.d.ts.map