import { Engine, BodyId, Zodiac } from "./chart.js";
export declare const TROPICAL_YEAR = 365.24219;
/** Shorter-arc midpoint of two longitudes (degrees). */
export declare function midpointLon(a: number, b: number): number;
/** UT JDs in [jdStart, jdEnd] when `body` returns to its natal longitude.
 *  Outer-planet returns can show three crossings around a retrograde loop. */
export declare function returns(engine: Engine, body: BodyId, natalJd: number, jdStart: number, jdEnd: number, zodiac?: Zodiac, maxHits?: number): number[];
/**
 * Solar-return instants in `[jdStart, jdEnd]`: the times the Sun returns to its
 * natal longitude (about once a year). Build a chart at each with
 * {@link Engine.chartAt} for the solar-return chart.
 *
 * @param engine The engine used to evaluate positions.
 * @param natalJd Natal Julian Day (UT) — defines the target Sun longitude.
 * @param jdStart Start of the search window, Julian Day (UT).
 * @param jdEnd End of the search window, Julian Day (UT).
 * @param zodiac Zodiac for the longitude match. Defaults to tropical.
 * @returns Return instants as Julian Days (UT), sorted.
 * @example
 * ```ts
 * const natal = julianDay(1990, 6, 10, 14, 30);
 * const [thisYear] = solarReturn(engine, natal, julianDay(2025, 1, 1), julianDay(2026, 1, 1));
 * const returnChart = engine.chartAt(thisYear, 27.95, -82.46);
 * ```
 * @see {@link lunarReturn} for the monthly Moon return.
 */
export declare function solarReturn(engine: Engine, natalJd: number, jdStart: number, jdEnd: number, zodiac?: Zodiac): number[];
export declare function lunarReturn(engine: Engine, natalJd: number, jdStart: number, jdEnd: number, zodiac?: Zodiac): number[];
/** The JD whose real positions are the secondary-progressed positions for the
 *  age (targetJd - natalJd): one day of motion per year of life. */
export declare function progressedJd(natalJd: number, targetJd: number, yearLength?: number): number;
/**
 * Secondary-progressed longitude of a body for a given target date: the
 * "day-for-a-year" method, where one day of real motion after birth maps to one
 * year of life. Equivalent to taking the body's longitude at
 * {@link progressedJd}.
 *
 * @param engine The engine used to evaluate positions.
 * @param body A body id from {@link Engine.bodies}.
 * @param natalJd Natal Julian Day (UT).
 * @param targetJd The date to progress to, Julian Day (UT).
 * @param yearLength Days per year of life. Defaults to the tropical year.
 * @param zodiac Zodiac for the result. Defaults to tropical.
 * @returns The progressed ecliptic longitude in degrees, `[0, 360)`.
 * @example
 * ```ts
 * const natal = julianDay(1990, 6, 10, 14, 30);
 * progressedLongitude(engine, "moon", natal, julianDay(2025, 6, 10));
 * ```
 * @see {@link solarArc} and {@link directedLongitude} for solar-arc directions.
 */
export declare function progressedLongitude(engine: Engine, body: BodyId, natalJd: number, targetJd: number, yearLength?: number, zodiac?: Zodiac): number;
/** Solar-arc direction angle (degrees, forward): how far the secondary-
 *  progressed Sun has moved from the natal Sun. Add it to any natal longitude. */
export declare function solarArc(engine: Engine, natalJd: number, targetJd: number, yearLength?: number, zodiac?: Zodiac): number;
export declare function directedLongitude(engine: Engine, body: BodyId, natalJd: number, targetJd: number, yearLength?: number, zodiac?: Zodiac): number;
/** Midpoint-method composite: the shorter-arc midpoint of each body's two
 *  longitudes. Angles compose the same way via midpointLon on the two ASC/MC. */
export declare function compositeLongitudes(engine: Engine, jdA: number, jdB: number, bodies: BodyId[], zodiac?: Zodiac): Record<string, number>;
/** Time and place for a Davison relationship chart: the temporal midpoint and
 *  the geographic midpoint (mean latitude, shorter-arc mean longitude). Compute
 *  a normal chart at these to get the Davison chart. Returns [jd, lat, lonEast]. */
export declare function davisonParams(jdA: number, jdB: number, latA: number, lonEastA: number, latB: number, lonEastB: number): [number, number, number];
/** The nth-harmonic longitude of a point: lon * n, wrapped to 360. */
export declare function harmonicLongitude(lon: number, n: number): number;
/**
 * The nth-harmonic chart: each body's longitude multiplied by `n` and wrapped
 * to `[0, 360)`. The 5th harmonic surfaces quintiles, the 9th the navamsa, and
 * so on.
 *
 * @param engine The engine used to evaluate positions.
 * @param jd Julian Day (UT).
 * @param bodies The bodies to include.
 * @param n The harmonic number, e.g. `5` or `9`.
 * @param zodiac Zodiac for the base longitudes. Defaults to tropical.
 * @returns Harmonic longitudes in degrees, keyed by body id.
 * @example
 * ```ts
 * harmonicChart(engine, jd, ["sun", "moon", "venus"], 5); // quintile harmonic
 * ```
 */
export declare function harmonicChart(engine: Engine, jd: number, bodies: BodyId[], n: number, zodiac?: Zodiac): Record<string, number>;
/** Reflection across the solstice (Cancer-Capricorn) axis. */
export declare function antiscion(lon: number): number;
/** Reflection across the equinox (Aries-Libra) axis. */
export declare function contraAntiscion(lon: number): number;
export type DeclinationKind = "parallel" | "contraparallel" | null;
/** Classify two declinations: parallel (same), contraparallel (opposite), null. */
export declare function declinationAspect(decA: number, decB: number, orb?: number): DeclinationKind;
export interface DeclinationPair {
    a: string;
    b: string;
    kind: DeclinationKind;
}
/**
 * Parallels and contraparallels among a set of bodies at an instant: pairs
 * whose declinations are equal (parallel) or equal and opposite
 * (contraparallel) within `orb` — the declination analogue of conjunction and
 * opposition.
 *
 * @param engine The engine used to evaluate positions.
 * @param bodies The bodies to compare.
 * @param jd Julian Day (UT).
 * @param orb Declination orb in degrees. Defaults to `1.0`.
 * @returns {@link DeclinationPair}s `{ a, b, kind }`, where `kind` is
 *   `"parallel"` or `"contraparallel"`.
 */
export declare function declinationAspects(engine: Engine, bodies: BodyId[], jd: number, orb?: number): DeclinationPair[];
/** |declination| minus the mean obliquity, degrees. Positive = out of bounds. */
export declare function outOfBoundsMargin(engine: Engine, body: BodyId, jd: number): number;
export declare function outOfBounds(engine: Engine, body: BodyId, jd: number): boolean;
export declare function dignityOf(engine: Engine, body: BodyId, jd: number, zodiac?: Zodiac): string[];
/** Diurnal when the Sun is above the horizon at the given place. */
export declare function isDayChart(engine: Engine, jd: number, lat: number, lonEast: number): boolean;
/**
 * The sect a body belongs to: `"diurnal"` (Sun, Jupiter, Saturn),
 * `"nocturnal"` (Moon, Venus, Mars), or `null` for Mercury and bodies without a
 * fixed sect. Whether a chart is itself day or night — the Sun above or below
 * the horizon — is a separate question.
 *
 * @param body Body id.
 * @returns `"diurnal"`, `"nocturnal"`, or `null`.
 */
export declare function planetarySect(body: string): "diurnal" | "nocturnal" | null;
export declare function inSect(body: string, dayChart: boolean): boolean | null;