import type { TargetStatus } from '../_shared/target-tile';
import type { PracticeAnamnesisConfig } from './anamnesis-config';
import type { NumericParameterDef } from './anamnesis-types';
export type { TargetStatus };
/** The strip is the practice's CHOSEN goals — every live parameter whose
 * `goal` flag is set, in capture display order. The kit seeds the four
 * figures a nutrition plan is written in (weight, BMI, daily energy,
 * protein), and the configuration editor's Targets tab toggles the set. A
 * parameter the practice archived is simply absent, so a practice that does
 * not estimate intake gets a two-tile strip rather than a tile reading from
 * nothing. */
export declare function stripParameters(config?: PracticeAnamnesisConfig): NumericParameterDef[];
/** How wide "on target" and "approaching" are for one parameter.
 *
 * `kind` — `absolute` bands are in the parameter's own unit; `relative` ones
 * are a fraction of the target. Absolute is right where the scale itself is
 * narrow and fixed (BMI); relative is right where the target's magnitude
 * varies patient to patient (weight, energy, protein).
 *
 * `sided` — `both` counts an overshoot as a miss; `atLeast` treats the target
 * as a FLOOR (at or above it is met); `atMost` as a CAP. */
export interface TargetBand {
    kind: 'absolute' | 'relative';
    /** Within this of the target = on target. */
    onTarget: number;
    /** Within this = approaching; beyond it = off target. */
    approaching: number;
    sided: 'both' | 'atLeast' | 'atMost';
}
/** Per-parameter bands. Each comment is the clinical reason for the width. */
export declare const TARGET_BANDS: Readonly<Record<string, TargetBand>>;
/** The band for a parameter the practice added itself. Two-sided 5% / 15% —
 * wide enough not to shout at a measurement's own noise, narrow enough that
 * "on target" still means something. */
export declare const DEFAULT_TARGET_BAND: TargetBand;
/** The band a parameter is judged by. Never throws on an unknown key. */
export declare function targetBandFor(parameterKey: string): TargetBand;
/** Where `now` stands against `target`. `null` whenever the question cannot be
 * asked — no target set, or nothing measured yet — so the tile shows no
 * traffic light rather than a green one it has not earned. */
export declare function targetStatus(now: number | null, target: number | null, parameterKey: string): TargetStatus | null;
/** The range and granularity the target editor accepts for one parameter. */
export interface TargetBounds {
    min: number;
    max: number;
    step: number;
}
/** Physiologically sane editor bounds. Wide enough for any real patient,
 * narrow enough that a slipped decimal point is rejected at the input. */
export declare const TARGET_BOUNDS: Readonly<Record<string, TargetBounds>>;
/** Bounds for a parameter, falling back to a non-negative range stepped at the
 * parameter's own precision so a practice-added target is still editable. */
export declare function targetBoundsFor(def: NumericParameterDef): TargetBounds;
/** Whether a drafted target may be committed. Out-of-bounds is rejected at the
 * editor rather than clamped: silently changing a clinician's 620 to 400 is
 * worse than refusing it. `null` is always committable — it clears. */
export declare function isTargetInBounds(draft: number | null, bounds: TargetBounds): boolean;
//# sourceMappingURL=anamnesis-targets.d.ts.map