import type { IntakeFieldDef, IntakeSectionDef, NumericParameterDef, ParameterGroup, PathologyCode } from './anamnesis-types';
/** The only keys the derivation engine cannot lose. `bmi` is computed from
 * `weight` + `height`; every other key in the kit is read generically. */
export declare const LOCKED_PARAMETER_KEYS: ReadonlySet<string>;
/** Whether a numeric parameter is locked against archiving / deletion. */
export declare function isParameterLocked(key: string): boolean;
/** Whether a per-patient target can be set for this parameter. Decided by the
 * definition, not by a fixed list: its own `targetable` flag, or `goal` — a
 * goal the practice tracks is targetable by definition. Not every number is
 * one: a height is a fact about the patient, and a blood test carries a
 * population reference range rather than a target. The kit seeds `targetable`
 * on the four figures the nutrition plan is written in — weight, BMI, daily
 * energy, protein — plus waist, which practices have long set a goal for; a
 * host sets it (or `goal`) on any numeric question a practice marks as a
 * goal. */
export declare function isParameterTargetable(def: NumericParameterDef): boolean;
/** @deprecated Pass the `NumericParameterDef`. A bare key answers for the
 * kit's seeded catalogue only — it cannot see a practice's own vocabulary, so
 * a parameter the practice added is never targetable through this form. */
export declare function isParameterTargetable(key: string): boolean;
/** The kit's seeded targetable parameters — weight, BMI, waist, daily energy,
 * protein. Derived from the catalogue, so it describes the seed and is not the
 * rule: a practice's own vocabulary is answered by `isParameterTargetable`
 * on the definition. */
export declare const TARGETABLE_PARAMETER_KEYS: ReadonlySet<string>;
/** A practice's anamnesis vocabulary. Every list is optional: an omitted list
 * falls back to the kit-seeded catalogue, so `undefined` is a fully working
 * configuration and every existing mount keeps rendering unchanged. */
export interface PracticeAnamnesisConfig {
    /** Numeric parameters (anthropometrics + labs), in the practice's order. */
    parameters?: readonly NumericParameterDef[];
    /** The intake questionnaire — the practice's own form, transcribed. */
    intakeSections?: readonly IntakeSectionDef[];
    /** The coded pathology taxonomy. */
    pathologies?: readonly PathologyCode[];
}
/** What the kit ships when a practice has configured nothing. Seeded, not
 * empty — an empty vocabulary renders an empty record. */
export declare const SEEDED_ANAMNESIS_CONFIG: Required<PracticeAnamnesisConfig>;
/** Fill every omitted list from the seed. */
export declare function resolveConfig(config?: PracticeAnamnesisConfig): Required<PracticeAnamnesisConfig>;
/** CAPTURE surfaces: live parameters only. A locked parameter is never
 * dropped, whatever the config says — archiving `weight` would silently break
 * BMI everywhere. */
export declare function configuredParameters(config?: PracticeAnamnesisConfig, group?: ParameterGroup): NumericParameterDef[];
/** HISTORY surfaces: every parameter, archived ones included, so a value
 * recorded under an archived parameter still renders. */
export declare function allParametersIncludingArchived(config?: PracticeAnamnesisConfig, group?: ParameterGroup): NumericParameterDef[];
/** Lookup over every parameter, archived included — callers resolving a key
 * read from a record must never miss an archived one. */
export declare function parameterLookup(config?: PracticeAnamnesisConfig): Record<string, NumericParameterDef>;
/** CAPTURE: the questionnaire as the patient sees it — archived sections and
 * fields dropped, and a section left with no live field dropped with them. */
export declare function configuredSections(config?: PracticeAnamnesisConfig): IntakeSectionDef[];
/** HISTORY: every section and field ever configured, so answers recorded under
 * a since-archived question still render in the record and the read-only view.
 * Using `configuredSections` here would erase them from the screen. */
export declare function allSectionsIncludingArchived(config?: PracticeAnamnesisConfig): IntakeSectionDef[];
/** Flat field lookup across every section, archived included. */
export declare function intakeFieldLookup(config?: PracticeAnamnesisConfig): Record<string, IntakeFieldDef>;
/** CAPTURE: live codes, in configured order. */
export declare function configuredPathologies(config?: PracticeAnamnesisConfig): PathologyCode[];
/** HISTORY: every code, archived included. A code assigned last year must
 * still render its label this year. */
export declare function allPathologiesIncludingArchived(config?: PracticeAnamnesisConfig): PathologyCode[];
/** Lookup by code over the FULL taxonomy. Without this, reading
 * `entry.parentCode` off a practice-added code throws. */
export declare function pathologyLookup(config?: PracticeAnamnesisConfig): Record<string, PathologyCode>;
/** Assignable codes: a family that carries sub-codes is a heading, not itself
 * assignable. Derived from the LIVE taxonomy so an archived code cannot be
 * newly assigned, but stays resolvable for history. */
export declare function assignablePathologyCodes(config?: PracticeAnamnesisConfig): string[];
//# sourceMappingURL=anamnesis-config.d.ts.map