export declare const ABSOLUTE_ZERO_TEMPERATURE_CELSIUS = -273.15;

export declare type Albedo = number;

export declare type AllPlanetName = 'Mercury' | 'Venus' | 'Mars' | 'Jupiter' | 'Saturn' | 'Uranus' | 'Neptune' | 'Pluto';

export declare const AllPlanets: {
    [key in AllPlanetName]: Planet | DwarfPlanet;
};

export declare type ArcMinute = number;

export declare type ArcSecond = number;

export declare type AstronomicalUnit = number;

export declare const AVERAGE_ANOMALISTIC_YEAR: Day;

export declare const AVERAGE_ECLIPSE_YEAR: Day;

export declare const AVERAGE_GREGORIAN_YEAR: Day;

export declare const AVERAGE_JULIAN_YEAR: Day;

export declare const AVERAGE_SIDEREAL_YEAR: Day;

export declare const AVERAGE_TROPICAL_YEAR: Day;

export declare const BESSELIAN_YEAR: Day;

export declare const BOLTZMANN_CONSTANT = 1.3806488e-23;

export declare type Celsius = number;

export declare const CONSTANT_OF_ABERRATION = 20.49552;

declare namespace coordinates {
    export {
        getParallacticAngle,
        getGreatCircleAngularDistance,
        getRightAscensionFromEcliptic,
        getDeclinationFromEcliptic,
        transformEclipticToEquatorial,
        getEclipticLongitudeFromEquatorial,
        getEclipticLatitudeFromEquatorial,
        transformEquatorialToEcliptic,
        getGalacticLongitudeFromEquatorial,
        getGalacticLatitudeFromEquatorial,
        transformEquatorialToGalactic,
        getHorizontalAltitude,
        getHorizontalAzimuth,
        transformEquatorialToHorizontal,
        transformEquatorialToTopocentric,
        getCorrectionInLongitude,
        getCorrectionInLatitude,
        getEquatorialRightAscensionB1950FromGalactic,
        getEquatorialDeclinationB1950FromGalactic,
        transformGalacticToEquatorial,
        getRightAscensionFromHorizontal,
        getDeclinationFromHorizontal,
        transformHorizontalToEquatorial,
        transformPointToHorizontal,
        transformHorizontalToPoint,
        precessEquatorialCoordinates,
        precessEquatorialCoordinatesFromJ2000ToB1950,
        precessEquatorialCoordinatesFromB1950ToJ2000
    }
}
export { coordinates }

export declare type Coordinates2D = {
    X: number;
    Y: number;
};

export declare type Coordinates3D = {
    X: number;
    Y: number;
    Z: number;
};

declare namespace cosmology {
    export {
        getUniverseAge,
        getUniverseAgeAtRedshift,
        getLightTravelTime,
        getAngularSizeDistance,
        getAngularSizeScale,
        getLuminosityDistance,
        getComovingRadialDistance,
        getTangentialComovingDistance,
        getOmegaR,
        getOmegaK,
        getComovingVolume,
        getComovingVolumeWithinRedshift
    }
}
export { cosmology }

export declare type Day = number;

export declare const DAYMS: MiliSecond;

export declare const DEG2H: Hour;

export declare const DEG2RAD: Radian;

export declare type Degree = number;

declare namespace distances {
    export {
        getParallaxFromParsecs,
        getParsecsFromParallax,
        getAstronomicalUnitsFromParsecs,
        getParsecsFromAstronomicalUnits,
        getKilometersFromParsecs,
        getParsecsFromKilometers,
        getLightYearsFromParsecs,
        getParsecsFromLightYears,
        getDistanceModulusFromParsecs,
        getParsecsFromDistanceModulus,
        getRedshiftFromMegaparsecs,
        getMegaparsecsFromRedshift,
        getLightTimeFromDistance
    }
}
export { distances }

export declare interface DwarfPlanet extends PlanetBase {
}

export declare const Earth: NaturalEarth;

export declare const EARTH_EQUATORIAL_RADIUS: Kilometer;

export declare const EARTH_MERIDIAN_ECCENTRICITY: number;

export declare const EARTH_RADIUS_FLATTENING_FACTOR: number;

export declare const ECLIPTIC_OBLIQUITY_B1950_0: Degree;

export declare const ECLIPTIC_OBLIQUITY_J2000_0: Degree;

export declare type EclipticCoordinates = {
    longitude: Degree;
    latitude: Degree;
};

export declare type EclipticCoordinatesAtJulianDayFunction = (jd: JulianDay) => EclipticCoordinates;

export declare type EclipticCoordinatesAtJulianDayWithEquinoxFunction = (jd: JulianDay, equinox?: Equinox) => EclipticCoordinates;

export declare type EclipticCoordinatesCorrection = {
    DeltaLongitude: ArcSecond;
    DeltaLatitude: ArcSecond;
};

export declare type EquatorialCoordinates = {
    rightAscension: Degree;
    declination: Degree;
    epoch?: JulianDay;
};

export declare type EquatorialCoordinatesAtJulianDayFunction = (jd: JulianDay) => EquatorialCoordinates;

export declare type EquatorialCoordinatesAtJulianDayWithEquinoxFunction = (jd: JulianDay, equinox?: Equinox) => EquatorialCoordinates;

export declare type EquatorialCoordinatesAtJulianDayWithObliquityFunction = (jd: JulianDay, obliquity?: Obliquity) => EquatorialCoordinates;

export declare type EquatorialCoordinatesCorrection = {
    DeltaRightAscension: ArcSecond;
    DeltaDeclination: ArcSecond;
};

export declare enum Equinox {
    MeanOfTheDate = "MeanOfTheDate",
    StandardJ2000 = "StandardJ2000"
}

declare namespace exoplanets {
    export {
        julianDayOfNextTransit,
        getExoplanetTransitDetails,
        getTransitAltitude
    }
}
export { exoplanets }

export declare function fmod(a: number, b: number): number;

export declare function fmod180(degrees: Degree): Degree;

export declare function fmod24(hours: Hour): Hour;

export declare function fmod360(degrees: Degree): Degree;

export declare function fmod90(degrees: Degree): Degree;

export declare const GALACTIC_NORTH_POLE_ALPHA_B1950_0: Degree;

export declare const GALACTIC_NORTH_POLE_DELTA_B1950_0: Degree;

export declare type GalacticCoordinates = {
    longitude: Degree;
    latitude: Degree;
};

export declare type GeographicCoordinates = {
    longitude: Degree;
    latitude: Degree;
    height?: Meter;
};

declare function getAccurateRiseTransitSetTimes(jd: JulianDay, equCoords: LengthArray<EquatorialCoordinates, 3>, geoCoords: GeographicCoordinates, alt?: Degree, iterations?: number): RiseTransitSet;

declare function getAngularSizeDistance(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): MegaParsec;

declare function getAngularSizeScale(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): KiloparsecPerArcsecond;

declare function getApparentLocalSiderealTime(jd: JulianDay, lng: Degree): Hour;

declare function getAstronomicalUnitsFromParsecs(pc: Parsec): AstronomicalUnit;

declare function getComovingRadialDistance(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): MegaParsec;

declare function getComovingVolume(omegaK: number, DCMR: number): GigaParsec3;

declare function getComovingVolumeWithinRedshift(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): GigaParsec3;

declare function getCorrectionInLatitude(jd: JulianDay, lng: Degree): Degree;

declare function getCorrectionInLongitude(jd: JulianDay, lng: Degree, lat: Degree): Degree;

declare function getDate(jd: JulianDay): Date;

declare function getDecimalValue(d: number, m: number, s: number): number;

declare function getDecimalYear(jd: JulianDay, isGregorianCalendar?: boolean): number;

declare function getDeclinationFromEcliptic(coords: EclipticCoordinates, epsilon?: Degree): Degree;

declare function getDeclinationFromHorizontal(horCoords: HorizontalCoordinates, geoCoords: GeographicCoordinates): Degree;

declare function getDeltaT(jd: JulianDay): number;

declare function getDistanceModulusFromParsecs(pc: Parsec, visualAbsorption?: Magnitude): Magnitude;

declare function getEclipticLatitudeFromEquatorial(coords: EquatorialCoordinates, epsilon?: Degree): Degree;

declare function getEclipticLongitudeFromEquatorial(coords: EquatorialCoordinates, epsilon?: Degree): Degree;

declare function getEquatorialDeclinationB1950FromGalactic(coords: GalacticCoordinates): Degree;

declare function getEquatorialRightAscensionB1950FromGalactic(coords: GalacticCoordinates): Degree;

declare function getExoplanetTransitDetails(orbitalPeriod: Day, lambdaAngle: Degree, timeOfPeriastron: JulianDay, eccentricity: number, radius: JupiterRadius, semiMajorAxis: AstronomicalUnit, parentStarRadius: SolarRadius): {
    duration: number;
    start: number;
    center: number;
    end: number;
};

declare function getFractionalYear(jd: JulianDay, isGregorianCalendar?: boolean): number;

declare function getFullScaleJulianDay(Year: Year, Month: Month, Day: Day, isGregorianCalendar?: boolean): JulianDay;

declare function getGalacticLatitudeFromEquatorial(coords: EquatorialCoordinates, epoch?: JulianDay): Degree;

declare function getGalacticLongitudeFromEquatorial(coords: EquatorialCoordinates, epoch?: JulianDay): Degree;

declare function getGreatCircleAngularDistance(coords1: EquatorialCoordinates, coords2: EquatorialCoordinates): Degree;

declare function getGreenwichSiderealTime(jd: JulianDay): Hour;

declare function getHorizontalAltitude(jd: JulianDay, equCoords: EquatorialCoordinates, geoCoords: GeographicCoordinates): Degree;

declare function getHorizontalAzimuth(jd: JulianDay, equCoords: EquatorialCoordinates, geoCoords: GeographicCoordinates): Degree;

declare function getJulianCentury(jd: JulianDay): JulianCentury;

declare function getJulianDay(...args: any[]): JulianDay;

declare function getJulianDayMidnight(jd: JulianDay): JulianDay;

declare function getJulianDayMidnightDynamicalTime(jd: JulianDay): JulianDay;

declare function getJulianMillenium(jd: JulianDay): JulianMillenium;

declare function getKilometersFromParsecs(pc: Parsec): Kilometer;

declare function getLightTimeFromDistance(distance: AstronomicalUnit): Day;

declare function getLightTravelTime(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): GYr;

declare function getLightYearsFromParsecs(pc: Parsec): LightYear;

declare function getLocalSiderealTime(jd: JulianDay, lng: Degree): Hour;

declare function getLuminosityDistance(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): MegaParsec;

declare function getMegaparsecsFromRedshift(z: number, hubbleConstant?: KilometerPerSecondPerMegaParsec): MegaParsec;

declare function getModifiedJulianDay(jd: JulianDay): JulianDay;

declare function getOmegaK(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number): number;

declare function getOmegaR(H0: KilometerPerSecondPerMegaParsec): number;

declare function getParallacticAngle(jd: JulianDay, equCoords: EquatorialCoordinates, geoCoords: GeographicCoordinates): Degree;

declare function getParallaxFromParsecs(parsec: Parsec): ArcSecond;

declare function getParsecsFromAstronomicalUnits(AU: AstronomicalUnit): Parsec;

declare function getParsecsFromDistanceModulus(mM: Magnitude, visualAbsorption?: Magnitude): Parsec;

declare function getParsecsFromKilometers(km: Kilometer): Parsec;

declare function getParsecsFromLightYears(ly: LightYear): Parsec;

declare function getParsecsFromParallax(arcseconds: ArcSecond): Parsec;

declare function getRedshiftFromMegaparsecs(Mpc: MegaParsec, hubbleConstant?: KilometerPerSecondPerMegaParsec): number;

declare function getRightAscensionFromEcliptic(coords: EclipticCoordinates, epsilon?: Degree): Degree;

declare function getRightAscensionFromHorizontal(jd: JulianDay, horCoords: HorizontalCoordinates, geoCoords: GeographicCoordinates): Degree;

declare function getRiseTransitSetTimes(jd: JulianDay, equCoords: EquatorialCoordinates, geoCoords: GeographicCoordinates, alt?: Degree): RiseTransitSet;

declare function getSexagesimalValue(decimalValue: number): Sexagesimal;

declare function getTangentialComovingDistance(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): number;

declare function getTransitAltitude(equCoords: EquatorialCoordinates, geoCoords: GeographicCoordinates, transitJD?: JulianDay | undefined): Degree;

declare function getUniverseAge(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number): GYr;

declare function getUniverseAgeAtRedshift(H0: KilometerPerSecondPerMegaParsec, omegaMat: number, omegaVac: number, z: number): GYr;

export declare type GigaParsec3 = number;

export declare type GramPerCubicCentimeter = number;

export declare type GYr = number;

export declare const H2DEG: Degree;

export declare const H2RAD: Radian;

export declare type HorizontalCoordinates = {
    azimuth: Degree;
    altitude: Degree;
};

export declare type Hour = number;

export declare const HUBBLE_CONSTANT = 72;

export declare function isNegative(v: any): boolean;

export declare function isNumber(v: any): boolean;

export declare function isPositive(v: any): boolean;

export declare const J1970: JulianDay;

export declare const J2000: JulianDay;

export declare const JULIAN_DAY_B1950_0: JulianDay;

export declare const JULIAN_YEAR: Day;

export declare type JulianCentury = number;

export declare type JulianDay = number;

export declare type JulianDayForJulianDayFunction = (jd: JulianDay) => JulianDay;

declare function julianDayOfNextTransit(lowerJD: JulianDay, orbitalPeriod: Day, tZeroOfTransit: JulianDay): number;

declare namespace juliandays {
    export {
        getDate,
        getJulianDay,
        getLocalSiderealTime,
        getGreenwichSiderealTime,
        getApparentLocalSiderealTime,
        getModifiedJulianDay,
        getJulianDayMidnight,
        getJulianDayMidnightDynamicalTime,
        getJulianCentury,
        getJulianMillenium
    }
}
export { juliandays }

export declare type JulianEphemerisDay = number;

export declare type JulianMillenium = number;

export declare const Jupiter: JupiterPlanet;

export declare type JupiterCentralMeridianLongitudes = {
    geometricSystemI: Degree;
    geometricSystemII: Degree;
    apparentSystemI: Degree;
    apparentSystemII: Degree;
};

export declare type JupiterCentralMeridianLongitudesFunction = (jd: JulianDay) => JupiterCentralMeridianLongitudes;

export declare interface JupiterPlanet extends Planet {
    getCentralMeridianLongitudes: JupiterCentralMeridianLongitudesFunction;
    getPlanetocentricDeclinationOfTheSun: QuantityInDegreeAtJulianDayFunction;
    getPlanetocentricDeclinationOfTheEarth: QuantityInDegreeAtJulianDayFunction;
}

export declare type JupiterRadius = number;

export declare type Kilogram = number;

export declare type Kilogram24 = number;

export declare type Kilometer = number;

export declare type KilometerPerSecond = number;

export declare type KilometerPerSecondPerMegaParsec = number;

export declare type KiloParsec = number;

export declare type KiloparsecPerArcsecond = number;

export declare type LengthArray<T, N extends number, R extends T[] = []> = number extends N ? T[] : R['length'] extends N ? R : LengthArray<T, N, [T, ...R]>;

export declare type LightYear = number;

export declare type Magnitude = number;

declare function makeCompactSexagesimal(value: number, showSeconds?: boolean): string;

declare function makeDecimalFloat(arr: Array<number> | null): number | null;

declare function makeDeclinationSexagesimal(degrees: number): string;

declare function makeHoursMinutesSexagesimal(value: number, showSeconds?: boolean): string;

declare function makeLatitudeSexagesimal(degrees: number): string;

declare function makeLongitudeSexagesimal(degrees: number): string;

declare function makeRightAscensionSexagesimal(degrees: number, showSeconds?: boolean): string;

declare function makeSexagesimal(options: object): string;

export declare const Mars: MarsPlanet;

export declare interface MarsPlanet extends Planet {
    getPlanetocentricDeclinationOfTheSun: QuantityInDegreeAtJulianDayFunction;
    getPlanetocentricDeclinationOfTheEarth: QuantityInDegreeAtJulianDayFunction;
}

export declare const MEARTH: Kilogram;

export declare type MegaParsec = number;

export declare const Mercury: Planet;

export declare type Meter = number;

export declare type MeterPerSquareSecond = number;

export declare type MiliSecond = number;

export declare type Minute = number;

export declare const MJD_START: JulianDay;

export declare const MJUP: Kilogram;

export declare const MNEP: Kilogram;

export declare type Month = number;

export declare const MOON_PHASE_UPPER_LIMITS: {
    0: number;
    1: number;
    2: number;
    3: number;
    4: number;
    5: number;
    6: number;
    7: number;
};

export declare const MOON_SYNODIC_PERIOD: Day;

export declare enum MoonPhase {
    New = 0,
    WaxingCrescent = 1,
    FirstQuarter = 2,
    WaxingGibbous = 3,
    Full = 4,
    WaningGibbous = 5,
    LastQuarter = 6,
    WaningCrescent = 7
}

export declare enum MoonPhaseQuarter {
    New = 0,
    FirstQuarter = 1,
    Full = 2,
    LastQuarter = 3
}

export declare const MSUN: Kilogram;

export declare interface NaturalEarth {
    getEclipticLongitude: SingleCoordinateDegreeAtJulianDayWithEquinoxFunction;
    getEclipticLongitudinalRotation: Function;
    getEclipticLatitude: SingleCoordinateDegreeAtJulianDayWithEquinoxFunction;
    getEclipticCoordinates: EclipticCoordinatesAtJulianDayWithEquinoxFunction;
    getRadiusVector: QuantityInAstronomicalUnitAtJulianDayFunction;
    getFlatteningCorrections: Function;
    getMeanAnomaly: QuantityAtJulianDayFunction;
    getEccentricity: QuantityAtJulianDayFunction;
    getLongitudeOfPerihelion: QuantityInDegreeAtJulianDayFunction;
    getNutationInLongitude: QuantityInArcSecondAtJulianDayFunction;
    getNutationInObliquity: QuantityInArcSecondAtJulianDayFunction;
    getMeanObliquityOfEcliptic: QuantityInDegreeAtJulianDayFunction;
    getTrueObliquityOfEcliptic: QuantityInDegreeAtJulianDayFunction;
    getEarthVelocity: Function;
    getAccurateAnnualEquatorialAberration: Function;
    getAnnualEclipticAberration: Function;
    getAnnualEquatorialAberration: Function;
    getNutationEquatorialAberration: Function;
    Moon: NaturalMoon;
}

export declare interface NaturalMoon {
    getGeocentricElongation: QuantityInDegreeAtJulianDayFunction;
    getMeanLongitude: QuantityInDegreeAtJulianDayFunction;
    getMeanElongation: QuantityInDegreeAtJulianDayFunction;
    getMeanAnomaly: QuantityInDegreeAtJulianDayFunction;
    getArgumentOfLatitude: QuantityInDegreeAtJulianDayFunction;
    getGeocentricEclipticLongitude: QuantityInDegreeAtJulianDayFunction;
    getGeocentricEclipticLatitude: QuantityInDegreeAtJulianDayFunction;
    getGeocentricEclipticCoordinates: EclipticCoordinatesAtJulianDayFunction;
    getGeocentricEquatorialCoordinates: EquatorialCoordinatesAtJulianDayWithObliquityFunction;
    getApparentGeocentricEquatorialCoordinates: EquatorialCoordinatesAtJulianDayFunction;
    getRadiusVectorInKilometer: QuantityInAstronomicalUnitAtJulianDayFunction;
    radiusVectorToHorizontalParallax: Function;
    horizontalParallaxToRadiusVector: Function;
    getMeanLongitudeAscendingNode: QuantityInDegreeAtJulianDayFunction;
    getMeanLongitudePerigee: QuantityInDegreeAtJulianDayFunction;
    trueLongitudeOfAscendingNode: QuantityInDegreeAtJulianDayFunction;
    horizontalParallax: QuantityInDegreeAtJulianDayFunction;
    getPhaseAngle: QuantityInDegreeAtJulianDayFunction;
    getIlluminatedFraction: QuantityAtJulianDayFunction;
    getEquatorialHorizontalParallax: QuantityInDegreeAtJulianDayFunction;
    getGeocentricSemiDiameter: QuantityInArcSecondAtJulianDayFunction;
    getPositionAngleOfTheBrightLimb: QuantityInDegreeAtJulianDayFunction;
    getTimeOfMeanPhase: Function;
    getAge: QuantityAtJulianDayFunction;
    getAgeName: Function;
    getTopocentricRadialVelocity: Function;
    getRiseTransitSet: RiseTransitSetTimesAtJulianDayAndGeographicCoordinatesFunction;
}

export declare interface NaturalSun {
    getMeanAnomaly: QuantityAtJulianDayFunction;
    getTrueAnomaly: QuantityAtJulianDayFunction;
    getEquationOfTheCenter: Function;
    getMeanLongitudeReferredToMeanEquinoxOfDate: QuantityInDegreeAtJulianCenturyFunction;
    getGeometricEclipticLongitude: QuantityInDegreeAtJulianDayFunction;
    getGeocentricEclipticLongitude: SingleCoordinateDegreeAtJulianDayWithEquinoxFunction;
    getGeocentricEclipticLatitude: SingleCoordinateDegreeAtJulianDayWithEquinoxFunction;
    getGeometricFK5EclipticLongitude: SingleCoordinateDegreeAtJulianDayWithEquinoxFunction;
    getGeometricFK5EclipticLatitude: SingleCoordinateDegreeAtJulianDayWithEquinoxFunction;
    getGeocentricEclipticCoordinates: EclipticCoordinatesAtJulianDayWithEquinoxFunction;
    getGeocentricEquatorialCoordinates: EquatorialCoordinatesAtJulianDayWithEquinoxFunction;
    getApparentGeocentricEclipticLongitude: SingleCoordinateDegreeAtJulianDayFunction;
    getApparentGeocentricEclipticLatitude: SingleCoordinateDegreeAtJulianDayFunction;
    getApparentGeocentricEclipticCoordinates: EclipticCoordinatesAtJulianDayFunction;
    getApparentGeocentricEquatorialCoordinates: EquatorialCoordinatesAtJulianDayFunction;
    getVariationGeometricEclipticLongitude: QuantityInDegreeAtJulianDayFunction;
    getRiseTransitSet: RiseTransitSetTimesAtJulianDayAndGeographicCoordinatesFunction;
    constants: SunConstants;
}

export declare const Neptune: Planet;

export declare enum Obliquity {
    Mean = "Mean",
    True = "True"
}

export declare const ONE_DAY_IN_SECONDS: Second;

export declare const ONE_MASS_OF_JUPITER_IN_EARTH_MASS = 317.8987545198875;

export declare const ONE_MASS_OF_JUPITER_IN_NEPTUNE_MASS = 18.539490383676657;

export declare const ONE_UA_IN_KILOMETERS: Kilometer;

export declare const ONE_YEAR_IN_SECONDS: Second;

export declare type Parsec = number;

export declare const PC2LY = 3.263797724738089;

export declare const PC2UA: number;

export declare const PI: Radian;

export declare const PIHALF: Radian;

export declare const PITWO: Radian;

export declare type Pixel = number;

export declare const PLANCK_CONSTANT = 6.62606957e-34;

export declare interface Planet extends PlanetBase {
    getInstantaneousVelocity: QuantityInKilometerPerSecondAtJulianDayFunction;
    getVelocityAtPerihelion: QuantityInKilometerPerSecondAtJulianDayFunction;
    getVelocityAtAphelion: QuantityInKilometerPerSecondAtJulianDayFunction;
    getLengthOfEllipse: QuantityInAstronomicalUnitAtJulianDayFunction;
    getMeanLongitude: QuantityInDegreeAtJulianDayWithEquinoxFunction;
    getEccentricity: QuantityAtJulianDayFunction;
    getInclination: QuantityInDegreeAtJulianDayWithEquinoxFunction;
    getLongitudeOfAscendingNode: QuantityInDegreeAtJulianDayWithEquinoxFunction;
    getLongitudeOfPerihelion: QuantityInDegreeAtJulianDayWithEquinoxFunction;
    getSemiMajorAxis: QuantityInDegreeAtJulianDayFunction;
    getAphelion: JulianDayForJulianDayFunction;
    getPerihelion: JulianDayForJulianDayFunction;
    orbitalElements: PlanetOrbitalElements;
}

export declare interface PlanetBase {
    getEclipticLongitude: SingleCoordinateDegreeAtJulianDayFunction;
    getEclipticLatitude: SingleCoordinateDegreeAtJulianDayFunction;
    getRadiusVector: QuantityInAstronomicalUnitAtJulianDayFunction;
    getEclipticCoordinates: EclipticCoordinatesAtJulianDayFunction;
    getEquatorialCoordinates: EquatorialCoordinatesAtJulianDayWithObliquityFunction;
    getGeocentricDistance: QuantityInAstronomicalUnitAtJulianDayFunction;
    getGeocentricEclipticCoordinates: EclipticCoordinatesAtJulianDayFunction;
    getApparentGeocentricEclipticCoordinates: EclipticCoordinatesAtJulianDayFunction;
    getGeocentricEquatorialCoordinates: EquatorialCoordinatesAtJulianDayWithObliquityFunction;
    getApparentGeocentricEquatorialCoordinates: EquatorialCoordinatesAtJulianDayFunction;
    getRiseTransitSet: RiseTransitSetTimesAtJulianDayAndGeographicCoordinatesFunction;
    getAccurateRiseTransitSet: RiseTransitSetTimesAtJulianDayAndGeographicCoordinatesFunction;
    getPhaseAngle: JulianDayForJulianDayFunction;
    getIlluminatedFraction: QuantityAtJulianDayFunction;
    getMagnitude: QuantityInMagnitudeAtJulianDayFunction;
    getEquatorialSemiDiameter: QuantityInArcSecondAtJulianDayFunction;
    getPolarSemiDiameter: QuantityInArcSecondAtJulianDayFunction;
    constants: PlanetConstants;
}

export declare type PlanetCoefficient = {
    A: number;
    B: number;
    C: number;
};

export declare type PlanetConstants = {
    equatorialRadius: Kilometer;
    meanRadius: Kilometer;
    mass: Kilogram24;
    bulkDensity: GramPerCubicCentimeter;
    siderealRotationPeriod: Day;
    siderealOrbitPeriod: Year;
    visualMagnitude: Magnitude;
    geometricAlbedo: Albedo;
    equatorialGravity: MeterPerSquareSecond;
    escapeVelocity: KilometerPerSecond;
};

export declare type PlanetName = 'Mercury' | 'Venus' | 'Mars' | 'Jupiter' | 'Saturn' | 'Uranus' | 'Neptune';

export declare type PlanetOrbitalElements = {
    semiMajorAxis: LengthArray<AstronomicalUnit, 4>;
    eccentricity: LengthArray<number, 4>;
    [Equinox.MeanOfTheDate]: {
        meanLongitude: LengthArray<Degree, 4>;
        inclination: LengthArray<Degree, 4>;
        longitudeOfAscendingNode: LengthArray<Degree, 4>;
        longitudeOfPerihelion: LengthArray<Degree, 4>;
    };
    [Equinox.StandardJ2000]: {
        meanLongitude: LengthArray<Degree, 4>;
        inclination: LengthArray<Degree, 4>;
        longitudeOfAscendingNode: LengthArray<Degree, 4>;
        longitudeOfPerihelion: LengthArray<Degree, 4>;
    };
};

export declare const Planets: {
    [key in PlanetName]: Planet;
};

export declare const Pluto: DwarfPlanet;

export declare type Point = {
    x: Pixel;
    y: Pixel;
};

export declare type PointNum = {
    x: number;
    y: number;
};

declare function precessEquatorialCoordinates(coords: EquatorialCoordinates, initialEpoch: JulianDay, finalEpoch: JulianDay): EquatorialCoordinates;

declare function precessEquatorialCoordinatesFromB1950ToJ2000(coords: EquatorialCoordinates): EquatorialCoordinates;

declare function precessEquatorialCoordinatesFromJ2000ToB1950(coords: EquatorialCoordinates): EquatorialCoordinates;

export declare type QuantityAtJulianDayFunction = (jd: JulianDay) => number;

export declare type QuantityInArcSecondAtJulianDayFunction = (jd: JulianDay) => ArcSecond;

export declare type QuantityInAstronomicalUnitAtJulianDayFunction = (jd: JulianDay) => AstronomicalUnit;

export declare type QuantityInDegreeAtJulianCenturyFunction = (jd: JulianCentury) => Degree;

export declare type QuantityInDegreeAtJulianDayFunction = (jd: JulianDay) => Degree;

export declare type QuantityInDegreeAtJulianDayWithEquinoxFunction = (jd: JulianDay, equinox?: Equinox) => Degree;

export declare type QuantityInKilometerPerSecondAtJulianDayFunction = (jd: JulianDay) => KilometerPerSecond;

export declare type QuantityInMagnitudeAtJulianDayFunction = (jd: JulianDay) => Magnitude;

export declare const RAD2DEG: Degree;

export declare const RAD2H: Hour;

export declare type Radian = number;

export declare type RiseTransitSet = {
    rise: {
        utc: Hour | undefined;
        julianDay: JulianDay | undefined;
    };
    transit: Transit;
    set: {
        utc: Hour | undefined;
        julianDay: JulianDay | undefined;
    };
};

declare namespace risetransitset {
    export {
        getAccurateRiseTransitSetTimes,
        getRiseTransitSetTimes
    }
}
export { risetransitset }

export declare type RiseTransitSetTimesAtJulianDayAndGeographicCoordinatesFunction = (jd: JulianDay, geoCoords: GeographicCoordinates) => RiseTransitSet;

export declare const Saturn: SaturnPlanet;

export declare type SaturnicentricCoordinates = {
    longitude: Degree;
    latitude: Degree;
};

export declare interface SaturnPlanet extends Planet {
    getRingSystemDetails: SaturnRingSystemFunction;
}

export declare interface SaturnRingSystem {
    majorAxis: ArcSecond;
    minorAxis: ArcSecond;
    northPolePositionAngle: Degree;
    saturnicentricSunEarthLongitudesDifference: Degree;
    earthCoordinates: SaturnicentricCoordinates;
    sunCoordinates: SaturnicentricCoordinates;
}

export declare type SaturnRingSystemFunction = (jd: JulianDay) => SaturnRingSystem;

export declare type Second = number;

export declare type Sexagesimal = {
    sign: number;
    radix: number;
    minutes: number;
    seconds: number;
    milliseconds: number;
};

declare namespace sexagesimal {
    export {
        getDecimalValue,
        getSexagesimalValue,
        makeSexagesimal,
        makeHoursMinutesSexagesimal,
        makeCompactSexagesimal,
        makeRightAscensionSexagesimal,
        makeDeclinationSexagesimal,
        makeLongitudeSexagesimal,
        makeLatitudeSexagesimal,
        makeDecimalFloat
    }
}
export { sexagesimal }

export declare const SIDEREAL_OVER_SOLAR_RATE: Day;

export declare type SingleCoordinateDegreeAtJulianDayFunction = (jd: JulianDay) => Degree;

export declare type SingleCoordinateDegreeAtJulianDayWithEquinoxFunction = (jd: JulianDay, equinox?: Equinox) => Degree;

export declare type SolarRadius = number;

export declare const SolarSystem: {
    [key in SolarSystemName]: NaturalSun | Planet | NaturalEarth | DwarfPlanet;
};

export declare type SolarSystemName = 'Sun' | 'Mercury' | 'Venus' | 'Earth' | 'Mars' | 'Jupiter' | 'Saturn' | 'Uranus' | 'Neptune' | 'Pluto';

export declare const SPEED_OF_LIGHT: KilometerPerSecond;

export declare const SPEED_OF_LIGHT_APPROX = 300000;

export declare const STANDARD_ALTITUDE_MOON: Degree;

export declare const STANDARD_ALTITUDE_STARS: Degree;

export declare const STANDARD_ALTITUDE_SUN: Degree;

export declare const Sun: NaturalSun;

export declare const SUN_EVENTS_ALTITUDES: Degree[];

export declare const SUN_EXTENDED_EVENTS_ALTITUDES: Degree[];

export declare type SunConstants = {
    equatorialRadius: Kilometer;
};

declare namespace times {
    export {
        getDecimalYear,
        getFractionalYear,
        getFullScaleJulianDay,
        transformTT2UTC,
        transformUTC2TT,
        transformTT2TAI,
        transformTAI2TT,
        transformTT2UT1,
        transformUT12TT,
        transformUT1MinusUTC,
        getDeltaT
    }
}
export { times }

export declare type TopocentricCoordinates = {
    rightAscension: Hour;
    declination: Degree;
    epoch?: JulianDay;
};

declare function transformEclipticToEquatorial(coords: EclipticCoordinates, epsilon?: Degree): EquatorialCoordinates;

declare function transformEquatorialToEcliptic(coords: EquatorialCoordinates, epsilon?: Degree): EclipticCoordinates;

declare function transformEquatorialToGalactic(coords: EquatorialCoordinates, epoch?: JulianDay): GalacticCoordinates;

declare function transformEquatorialToHorizontal(jd: JulianDay, equCoords: EquatorialCoordinates, geoCoords: GeographicCoordinates): HorizontalCoordinates;

declare function transformEquatorialToTopocentric(jd: JulianDay, coords: EquatorialCoordinates, distance: AstronomicalUnit, geoCoords: GeographicCoordinates): TopocentricCoordinates;

declare function transformGalacticToEquatorial(coords: GalacticCoordinates, epoch?: JulianDay): EquatorialCoordinates;

declare function transformHorizontalToEquatorial(jd: JulianDay, horCoords: HorizontalCoordinates, geoCoords: GeographicCoordinates): EquatorialCoordinates;

declare function transformHorizontalToPoint(horCoords: HorizontalCoordinates, center: Point, radius: number): Point;

declare function transformPointToHorizontal(point: Point, center: Point, radius: number): HorizontalCoordinates;

declare function transformTAI2TT(jd: JulianDay): number;

declare function transformTT2TAI(jd: JulianDay): number;

declare function transformTT2UT1(jd: JulianDay): number;

declare function transformTT2UTC(jd: JulianDay): number;

declare function transformUT12TT(jd: JulianDay): number;

declare function transformUT1MinusUTC(jd: JulianDay): number;

declare function transformUTC2TT(jd: JulianDay): number;

export declare type Transit = {
    utc: Hour | undefined;
    julianDay: JulianDay | undefined;
    altitude: Degree | undefined;
    refAltitude: Degree;
    isAboveHorizon: boolean;
    isAboveAltitude: boolean;
    isCircumpolar: boolean;
    internals: TransitInternals;
};

export declare type TransitInternals = {
    m0: number | undefined;
    cosH0: number | undefined;
};

export declare const Uranus: Planet;

export declare const Venus: Planet;

export declare type Year = number;

export { }