@hebcal/noaa 0.8.9 → 0.8.10

package/dist/index.d.ts

@@ -1,9 +1,7 @@
 import { Temporal } from 'temporal-polyfill';
 /**
  * A class that contains location information such as latitude and longitude required for astronomical calculations. The
- * elevation field may not be used by some calculation engines and would be ignored if set. Check the documentation for
- * specific implementations of the {@link AstronomicalCalculator} to see if elevation is calculated as part of the
- * algorithm.
+ * elevation field may not be used by some calculation engines and would be ignored if set.
  *
  * @author © Eliyahu Hershfeld 2004 - 2016
  * @version 1.1
@@ -27,53 +25,25 @@ export declare class GeoLocation {
      * @param {string} timeZoneId
      *            the <code>TimeZone</code> for the location.
      */
-    constructor(name: string | null, latitude: number, longitude: number, elevation: number, timeZoneId?: string);
-    /**
-     * GeoLocation constructor with parameters for all required fields.
-     *
-     * @param {string} name
-     *            The location name for display use such as &quot;Lakewood, NJ&quot;
-     * @param {number} latitude
-     *            the latitude in a double format such as 40.095965 for Lakewood, NJ.
-     *            <b>Note: </b> For latitudes south of the equator, a negative value should be used.
-     * @param {number} longitude
-     *            double the longitude in a double format such as -74.222130 for Lakewood, NJ.
-     *            <b>Note: </b> For longitudes west of the <a href="http://en.wikipedia.org/wiki/Prime_Meridian">Prime
-     *            Meridian </a> (Greenwich), a negative value should be used.
-     * @param {string} timeZoneId
-     *            the <code>TimeZone</code> for the location.
-     */
-    constructor(name: string | null, latitude: number, longitude: number, timeZoneId: string);
+    constructor(name: string | null, latitude: number, longitude: number, elevation: number, timeZoneId: string);
     /**
      * @private
-     * @see #getLatitude()
-     * @see #setLatitude(double)
-     * @see #setLatitude(int, int, double, String)
      */
     private latitude;
     /**
      * @private
-     * @see #getLongitude()
-     * @see #setLongitude(double)
-     * @see #setLongitude(int, int, double, String)
      */
     private longitude;
     /**
      * @private
-     * @see #getLocationName()
-     * @see #setLocationName(String)
      */
     private locationName;
     /**
      * @private
-     * @see #getTimeZone()
-     * @see #setTimeZone(TimeZone)
      */
     private timeZoneId;
     /**
      * @private
-     * @see #getElevation()
-     * @see #setElevation(double)
      */
     private elevation;
     /**
@@ -86,7 +56,7 @@ export declare class GeoLocation {
      * Method to set the elevation in Meters <b>above </b> sea level.
      *
      * @param {number} elevation
-     *            The elevation to set in Meters. An IllegalArgumentException will be thrown if the value is a negative.
+     *            The elevation to set in Meters. An Error will be thrown if the value is a negative.
      */
     setElevation(elevation: number): void;
     setLatitude(latitude: number): void;
@@ -113,13 +83,7 @@ export declare class GeoLocation {
      */
     getTimeZone(): string;
     /**
-     * Method to set the TimeZone. If this is ever set after the GeoLocation is set in the
-     * {@link AstronomicalCalendar}, it is critical that
-     * {@link AstronomicalCalendar#getCalendar()}.
-     * {@link java.util.Calendar#setTimeZone(TimeZone) setTimeZone(TimeZone)} be called in order for the
-     * AstronomicalCalendar to output times in the expected offset. This situation will arise if the
-     * AstronomicalCalendar is ever {@link AstronomicalCalendar#clone() cloned}.
-     *
+     * Method to set the TimeZone.
      * @param {string} timeZoneId
      *            The timeZone to set.
      */
@@ -141,14 +105,11 @@ export declare class GeoLocation {
 export declare class NOAACalculator {
     /**
      * A constructor that takes in <a href="http://en.wikipedia.org/wiki/Geolocation">geolocation</a> information as a
-     * parameter. The default {@link AstronomicalCalculator#getDefault() AstronomicalCalculator} used for solar
-     * calculations is the the {@link NOAACalculator}.
+     * parameter.
      *
      * @param {GeoLocation} geoLocation
      *            The location information used for calculating astronomical sun times.
      * @param {Temporal.PlainDate} date
-     *
-     * @see #setAstronomicalCalculator(AstronomicalCalculator) for changing the calculator class.
      */
     constructor(geoLocation: GeoLocation, date: Temporal.PlainDate);
     /**
@@ -163,8 +124,8 @@ export declare class NOAACalculator {
      * a point, and because the atmosphere refracts light, this 90&deg; zenith does not, in fact, correspond to true
      * sunset or sunrise, instead the center of the Sun's disk must lie just below the horizon for the upper edge to be
      * obscured. This means that a zenith of just above 90&deg; must be used. The Sun subtends an angle of 16 minutes of
-     * arc (this can be changed via the {@link #setSunRadius(double)} method , and atmospheric refraction accounts for
-     * 34 minutes or so (this can be changed via the {@link #setRefraction(double)} method), giving a total of 50
+     * arc, and atmospheric refraction accounts for
+     * 34 minutes or so, giving a total of 50
      * arcminutes. The total value for ZENITH is 90+(5/6) or 90.8333333&deg; for true sunrise/sunset.
      */
     /** Sun's zenith at civil twilight (96&deg;). */
@@ -185,23 +146,22 @@ export declare class NOAACalculator {
     private geoLocation;
     /**
      * The getSunrise method Returns a `Date` representing the
-     * {@link AstronomicalCalculator#getElevationAdjustment(double) elevation adjusted} sunrise time. The zenith used
-     * for the calculation uses {@link #GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
-     * {@link AstronomicalCalculator#getElevationAdjustment(double)}. This is adjusted by the
-     * {@link AstronomicalCalculator} to add approximately 50/60 of a degree to account for 34 archminutes of refraction
-     * and 16 archminutes for the sun's radius for a total of {@link AstronomicalCalculator#adjustZenith 90.83333&deg;}.
-     * See documentation for the specific implementation of the {@link AstronomicalCalculator} that you are using.
+     * {@link getElevationAdjustment elevation adjusted} sunrise time. The zenith used
+     * for the calculation uses {@link GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
+     * {@link getElevationAdjustment}. This is adjusted
+     * to add approximately 50/60 of a degree to account for 34 archminutes of refraction
+     * and 16 archminutes for the sun's radius for a total of {@link adjustZenith 90.83333&deg;}.
      *
      * @return {Temporal.ZonedDateTime | null} the `Date` representing the exact sunrise time. If the calculation can't be computed such as
      *         in the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
      *         does not set, a null will be returned. See detailed explanation on top of the page.
-     * @see AstronomicalCalculator#adjustZenith
-     * @see #getSeaLevelSunrise()
-     * @see AstronomicalCalendar#getUTCSunrise
+     * @see adjustZenith
+     * @see getSeaLevelSunrise()
+     * @see getUTCSunrise
      */
     getSunrise(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the sunrise without {@link AstronomicalCalculator#getElevationAdjustment(double) elevation
+     * A method that returns the sunrise without {@link getElevationAdjustment elevation
      * adjustment}. Non-sunrise and sunset calculations such as dawn and dusk, depend on the amount of visible light,
      * something that is not affected by elevation. This method returns sunrise calculated at sea level. This forms the
      * base for dawn calculations that are calculated as a dip below the horizon before sunrise.
@@ -209,44 +169,44 @@ export declare class NOAACalculator {
      * @return {Temporal.ZonedDateTime | null} the `Date` representing the exact sea-level sunrise time. If the calculation can't be computed
      *         such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one
      *         where it does not set, a null will be returned. See detailed explanation on top of the page.
-     * @see AstronomicalCalendar#getSunrise
-     * @see AstronomicalCalendar#getUTCSeaLevelSunrise
-     * @see #getSeaLevelSunset()
+     * @see getSunrise
+     * @see getUTCSeaLevelSunrise
+     * @see getSeaLevelSunset()
      */
     getSeaLevelSunrise(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the beginning of civil twilight (dawn) using a zenith of {@link #CIVIL_ZENITH 96&deg;}.
+     * A method that returns the beginning of civil twilight (dawn) using a zenith of {@link CIVIL_ZENITH 96&deg;}.
      *
      * @return {Temporal.ZonedDateTime | null} The `Date` of the beginning of civil twilight using a zenith of 96&deg;. If the calculation
      *         can't be computed, null will be returned. See detailed explanation on top of the page.
-     * @see #CIVIL_ZENITH
+     * @see CIVIL_ZENITH
      */
     getBeginCivilTwilight(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the beginning of nautical twilight using a zenith of {@link #NAUTICAL_ZENITH 102&deg;}.
+     * A method that returns the beginning of nautical twilight using a zenith of {@link NAUTICAL_ZENITH 102&deg;}.
      *
      * @return {Temporal.ZonedDateTime | null} The `Date` of the beginning of nautical twilight using a zenith of 102&deg;. If the
      *         calculation can't be computed null will be returned. See detailed explanation on top of the page.
-     * @see #NAUTICAL_ZENITH
+     * @see NAUTICAL_ZENITH
      */
     getBeginNauticalTwilight(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the beginning of astronomical twilight using a zenith of {@link #ASTRONOMICAL_ZENITH
+     * A method that returns the beginning of astronomical twilight using a zenith of {@link ASTRONOMICAL_ZENITH
      * 108&deg;}.
      *
      * @return {Temporal.ZonedDateTime | null} The `Date` of the beginning of astronomical twilight using a zenith of 108&deg;. If the
      *         calculation can't be computed, null will be returned. See detailed explanation on top of the page.
-     * @see #ASTRONOMICAL_ZENITH
+     * @see ASTRONOMICAL_ZENITH
      */
     getBeginAstronomicalTwilight(): Temporal.ZonedDateTime | null;
     /**
      * The getSunset method Returns a `Date` representing the
-     * {@link AstronomicalCalculator#getElevationAdjustment(double) elevation adjusted} sunset time. The zenith used for
-     * the calculation uses {@link #GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
-     * {@link AstronomicalCalculator#getElevationAdjustment(double)}. This is adjusted by the
-     * {@link AstronomicalCalculator} to add approximately 50/60 of a degree to account for 34 archminutes of refraction
-     * and 16 archminutes for the sun's radius for a total of {@link AstronomicalCalculator#adjustZenith 90.83333&deg;}.
-     * See documentation for the specific implementation of the {@link AstronomicalCalculator} that you are using. Note:
+     * {@link getElevationAdjustment elevation adjusted} sunset time. The zenith used for
+     * the calculation uses {@link GEOMETRIC_ZENITH geometric zenith} of 90&deg; plus
+     * {@link getElevationAdjustment}. This is adjusted
+     * to add approximately 50/60 of a degree to account for 34 archminutes of refraction
+     * and 16 archminutes for the sun's radius for a total of {@link adjustZenith 90.83333&deg;}.
+     * Note:
      * In certain cases the calculates sunset will occur before sunrise. This will typically happen when a timezone
      * other than the local timezone is used (calculating Los Angeles sunset using a GMT timezone for example). In this
      * case the sunset date will be incremented to the following date.
@@ -254,13 +214,13 @@ export declare class NOAACalculator {
      * @return {Temporal.ZonedDateTime | null} The `Date` representing the exact sunset time. If the calculation can't be computed such as in
      *         the Arctic Circle where there is at least one day a year where the sun does not rise, and one where it
      *         does not set, a null will be returned. See detailed explanation on top of the page.
-     * @see AstronomicalCalculator#adjustZenith
-     * @see #getSeaLevelSunset()
-     * @see AstronomicalCalendar#getUTCSunset
+     * @see adjustZenith
+     * @see getSeaLevelSunset()
+     * @see getUTCSunset
      */
     getSunset(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the sunset without {@link AstronomicalCalculator#getElevationAdjustment(double) elevation
+     * A method that returns the sunset without {@link getElevationAdjustment elevation
      * adjustment}. Non-sunrise and sunset calculations such as dawn and dusk, depend on the amount of visible light,
      * something that is not affected by elevation. This method returns sunset calculated at sea level. This forms the
      * base for dusk calculations that are calculated as a dip below the horizon after sunset.
@@ -268,34 +228,34 @@ export declare class NOAACalculator {
      * @return {Temporal.ZonedDateTime | null} The `Date` representing the exact sea-level sunset time. If the calculation can't be computed
      *         such as in the Arctic Circle where there is at least one day a year where the sun does not rise, and one
      *         where it does not set, a null will be returned. See detailed explanation on top of the page.
-     * @see AstronomicalCalendar#getSunset
-     * @see AstronomicalCalendar#getUTCSeaLevelSunset 2see {@link #getSunset()}
+     * @see getSunset
+     * @see getUTCSeaLevelSunset
      */
     getSeaLevelSunset(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the end of civil twilight using a zenith of {@link #CIVIL_ZENITH 96&deg;}.
+     * A method that returns the end of civil twilight using a zenith of {@link CIVIL_ZENITH 96&deg;}.
      *
-     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of civil twilight using a zenith of {@link #CIVIL_ZENITH 96&deg;}. If
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of civil twilight using a zenith of {@link CIVIL_ZENITH 96&deg;}. If
      *         the calculation can't be computed, null will be returned. See detailed explanation on top of the page.
-     * @see #CIVIL_ZENITH
+     * @see CIVIL_ZENITH
      */
     getEndCivilTwilight(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the end of nautical twilight using a zenith of {@link #NAUTICAL_ZENITH 102&deg;}.
+     * A method that returns the end of nautical twilight using a zenith of {@link NAUTICAL_ZENITH 102&deg;}.
      *
-     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of nautical twilight using a zenith of {@link #NAUTICAL_ZENITH 102&deg;}
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of nautical twilight using a zenith of {@link NAUTICAL_ZENITH 102&deg;}
      *         . If the calculation can't be computed, null will be returned. See detailed explanation on top of the
      *         page.
-     * @see #NAUTICAL_ZENITH
+     * @see NAUTICAL_ZENITH
      */
     getEndNauticalTwilight(): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns the end of astronomical twilight using a zenith of {@link #ASTRONOMICAL_ZENITH 108&deg;}.
+     * A method that returns the end of astronomical twilight using a zenith of {@link ASTRONOMICAL_ZENITH 108&deg;}.
      *
-     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of astronomical twilight using a zenith of {@link #ASTRONOMICAL_ZENITH
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the end of astronomical twilight using a zenith of {@link ASTRONOMICAL_ZENITH
      *         108&deg;}. If the calculation can't be computed, null will be returned. See detailed explanation on top
      *         of the page.
-     * @see #ASTRONOMICAL_ZENITH
+     * @see ASTRONOMICAL_ZENITH
      */
     getEndAstronomicalTwilight(): Temporal.ZonedDateTime | null;
     /**
@@ -313,30 +273,30 @@ export declare class NOAACalculator {
     static getTimeOffset(time: Temporal.ZonedDateTime | null, offset: number): Temporal.ZonedDateTime | null;
     /**
      * A utility method that returns the time of an offset by degrees below or above the horizon of
-     * {@link #getSunrise() sunrise}. Note that the degree offset is from the vertical, so for a calculation of 14&deg;
-     * before sunrise, an offset of 14 + {@link #GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
+     * {@link getSunrise() sunrise}. Note that the degree offset is from the vertical, so for a calculation of 14&deg;
+     * before sunrise, an offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
      *
      * @param {number} offsetZenith
-     *            the degrees before {@link #getSunrise()} to use in the calculation. For time after sunrise use
+     *            the degrees before {@link getSunrise} to use in the calculation. For time after sunrise use
      *            negative numbers. Note that the degree offset is from the vertical, so for a calculation of 14&deg;
-     *            before sunrise, an offset of 14 + {@link #GEOMETRIC_ZENITH} = 104 would have to be passed as a
+     *            before sunrise, an offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a
      *            parameter.
-     * @return {Temporal.ZonedDateTime | null} The `Date` of the offset after (or before) {@link #getSunrise()}. If the calculation
+     * @return {Temporal.ZonedDateTime | null} The `Date` of the offset after (or before) {@link getSunrise}. If the calculation
      *         can't be computed such as in the Arctic Circle where there is at least one day a year where the sun does
      *         not rise, and one where it does not set, a null will be returned. See detailed explanation on top of the
      *         page.
      */
     getSunriseOffsetByDegrees(offsetZenith: number): Temporal.ZonedDateTime | null;
     /**
-     * A utility method that returns the time of an offset by degrees below or above the horizon of {@link #getSunset()
+     * A utility method that returns the time of an offset by degrees below or above the horizon of {@link getSunset()
      * sunset}. Note that the degree offset is from the vertical, so for a calculation of 14&deg; after sunset, an
-     * offset of 14 + {@link #GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
+     * offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
      *
      * @param {number} offsetZenith
-     *            the degrees after {@link #getSunset()} to use in the calculation. For time before sunset use negative
+     *            the degrees after {@link getSunset} to use in the calculation. For time before sunset use negative
      *            numbers. Note that the degree offset is from the vertical, so for a calculation of 14&deg; after
-     *            sunset, an offset of 14 + {@link #GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
-     * @return {Temporal.ZonedDateTime | null} The `Date`of the offset after (or before) {@link #getSunset()}. If the calculation can't
+     *            sunset, an offset of 14 + {@link GEOMETRIC_ZENITH} = 104 would have to be passed as a parameter.
+     * @return {Temporal.ZonedDateTime | null} The `Date`of the offset after (or before) {@link getSunset}. If the calculation can't
      *         be computed such as in the Arctic Circle where there is at least one day a year where the sun does not
      *         rise, and one where it does not set, a null will be returned. See detailed explanation on top of the
      *         page.
@@ -350,7 +310,7 @@ export declare class NOAACalculator {
      *            the degrees below the horizon. For time after sunrise use negative numbers.
      * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
      *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
-     *         not set, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
      */
     getUTCSunrise0(zenith: number): number;
     /**
@@ -363,9 +323,9 @@ export declare class NOAACalculator {
      *            the degrees below the horizon. For time after sunrise use negative numbers.
      * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
      *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
-     *         not set, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
-     * @see AstronomicalCalendar#getUTCSunrise
-     * @see AstronomicalCalendar#getUTCSeaLevelSunset
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
+     * @see getUTCSunrise
+     * @see getUTCSeaLevelSunset
      */
     getUTCSeaLevelSunrise(zenith: number): number;
     /**
@@ -376,8 +336,8 @@ export declare class NOAACalculator {
      *            the degrees below the horizon. For time after sunset use negative numbers.
      * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
      *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
-     *         not set, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
-     * @see AstronomicalCalendar#getUTCSeaLevelSunset
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
+     * @see getUTCSeaLevelSunset
      */
     getUTCSunset0(zenith: number): number;
     /**
@@ -391,9 +351,9 @@ export declare class NOAACalculator {
      *            the degrees below the horizon. For time before sunset use negative numbers.
      * @return {number} The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
      *         Arctic Circle where there is at least one day a year where the sun does not rise, and one where it does
-     *         not set, {@link Double#NaN} will be returned. See detailed explanation on top of the page.
-     * @see AstronomicalCalendar#getUTCSunset
-     * @see AstronomicalCalendar#getUTCSeaLevelSunrise
+     *         not set, `NaN` will be returned. See detailed explanation on top of the page.
+     * @see getUTCSunset
+     * @see getUTCSeaLevelSunrise
      */
     getUTCSeaLevelSunset(zenith: number): number;
     /**
@@ -407,9 +367,9 @@ export declare class NOAACalculator {
      * Method to return the adjustment to the zenith required to account for the elevation. Since a person at a higher
      * elevation can see farther below the horizon, the calculation for sunrise / sunset is calculated below the horizon
      * used at sea level. This is only used for sunrise and sunset and not times before or after it such as
-     * {@link AstronomicalCalendar#getBeginNauticalTwilight() nautical twilight} since those
+     * {@link getBeginNauticalTwilight() nautical twilight} since those
      * calculations are based on the level of available light at the given dip below the horizon, something that is not
-     * affected by elevation, the adjustment should only made if the zenith == 90&deg; {@link #adjustZenith adjusted}
+     * affected by elevation, the adjustment should only made if the zenith == 90&deg; {@link adjustZenith adjusted}
      * for refraction and solar radius. The algorithm used is
      *
      * <pre>
@@ -437,30 +397,30 @@ export declare class NOAACalculator {
      * is not a point, and because the atmosphere refracts light, this 90&deg; zenith does not, in fact, correspond to
      * true sunset or sunrise, instead the centre of the Sun's disk must lie just below the horizon for the upper edge
      * to be obscured. This means that a zenith of just above 90&deg; must be used. The Sun subtends an angle of 16
-     * minutes of arc (this can be changed via the {@link #setSolarRadius(double)} method , and atmospheric refraction
-     * accounts for 34 minutes or so (this can be changed via the {@link #setRefraction(double)} method), giving a total
+     * minutes of arc, and atmospheric refraction
+     * accounts for 34 minutes or so, giving a total
      * of 50 arcminutes. The total value for ZENITH is 90+(5/6) or 90.8333333&deg; for true sunrise/sunset. Since a
      * person at an elevation can see blow the horizon of a person at sea level, this will also adjust the zenith to
      * account for elevation if available. Note that this will only adjust the value if the zenith is exactly 90 degrees.
      * For values below and above this no correction is done. As an example, astronomical twilight is when the sun is
-     * 18&deg; below the horizon or {@link AstronomicalCalendar#ASTRONOMICAL_ZENITH 108&deg;
+     * 18&deg; below the horizon or {@link ASTRONOMICAL_ZENITH 108&deg;
      * below the zenith}. This is traditionally calculated with none of the above mentioned adjustments. The same goes
      * for various <em>tzais</em> and <em>alos</em> times such as the
      * {@link ZmanimCalendar#ZENITH_16_POINT_1 16.1&deg;} dip used in
-     * {@link ComplexZmanimCalendar#getAlos16Point1Degrees()}.
+     * {@link ComplexZmanimCalendar#getAlos16Point1Degrees}.
      *
      * @param {number} zenith
-     *            the azimuth below the vertical zenith of 90&deg;. For sunset typically the {@link #adjustZenith
-     *            zenith} used for the calculation uses geometric zenith of 90&deg; and {@link #adjustZenith adjusts}
+     *            the azimuth below the vertical zenith of 90&deg;. For sunset typically the {@link adjustZenith
+     *            zenith} used for the calculation uses geometric zenith of 90&deg; and {@link adjustZenith adjusts}
      *            this slightly to account for solar refraction and the sun's radius. Another example would be
-     *            {@link AstronomicalCalendar#getEndNauticalTwilight()} that passes
-     *            {@link AstronomicalCalendar#NAUTICAL_ZENITH} to this method.
+     *            {@link getEndNauticalTwilight} that passes
+     *            {@link NAUTICAL_ZENITH} to this method.
      * @param {number} elevation
      *            elevation in Meters.
-     * @return {number} The zenith adjusted to include the {@link #getSolarRadius sun's radius}, {@link #getRefraction
-     *         refraction} and {@link #getElevationAdjustment elevation} adjustment. This will only be adjusted for
+     * @return {number} The zenith adjusted to include the sun's radius, refracton
+     *         and {@link getElevationAdjustment elevation} adjustment. This will only be adjusted for
      *         sunrise and sunset (if the zenith == 90&deg;)
-     * @see #getElevationAdjustment(double)
+     * @see getElevationAdjustment
      */
     adjustZenith(zenith: number, elevation: number): number;
     /**
@@ -474,18 +434,48 @@ export declare class NOAACalculator {
      */
     private static readonly JULIAN_DAYS_PER_CENTURY;
     /**
-     * @see AstronomicalCalculator#getUTCSunrise(Calendar, GeoLocation, double, boolean)
+     * A method that calculates UTC sunrise as well as any time based on an angle above or below sunrise.
+     * @param date
+     *            Used to calculate day of year.
+     * @param geoLocation
+     *            The location information used for astronomical calculating sun times.
+     * @param zenith
+     *            the azimuth below the vertical zenith of 90 degrees. for sunrise typically the {@link adjustZenith
+     *            zenith} used for the calculation uses geometric zenith of 90&deg; and {@link adjustZenith adjusts}
+     *            this slightly to account for solar refraction and the sun's radius. Another example would be
+     *            {@link getBeginNauticalTwilight} that passes
+     *            {@link NAUTICAL_ZENITH} to this method.
+     * @param adjustForElevation
+     *            Should the time be adjusted for elevation
+     * @return The UTC time of sunrise in 24 hour format. 5:45:00 AM will return 5.75.0. If an error was encountered in
+     *         the calculation (expected behavior for some locations such as near the poles,
+     *         `NaN` will be returned.
      */
     getUTCSunrise(date: Temporal.PlainDate, geoLocation: GeoLocation, zenith: number, adjustForElevation: boolean): number;
     /**
-     * @see AstronomicalCalculator#getUTCSunset(Calendar, GeoLocation, double, boolean)
+     * A method that calculates UTC sunset as well as any time based on an angle above or below sunset.
+     * @param date
+     *            Used to calculate day of year.
+     * @param geoLocation
+     *            The location information used for astronomical calculating sun times.
+     * @param zenith
+     *            the azimuth below the vertical zenith of 90&deg;. For sunset typically the {@link adjustZenith
+     *            zenith} used for the calculation uses geometric zenith of 90&deg; and {@link adjustZenith adjusts}
+     *            this slightly to account for solar refraction and the sun's radius. Another example would be
+     *            {@link getEndNauticalTwilight} that passes
+     *            {@link NAUTICAL_ZENITH} to this method.
+     * @param adjustForElevation
+     *            Should the time be adjusted for elevation
+     * @return The UTC time of sunset in 24 hour format. 5:45:00 AM will return 5.75.0. If an error was encountered in
+     *         the calculation (expected behavior for some locations such as near the poles,
+     *         `NaN` will be returned.
      */
     getUTCSunset(date: Temporal.PlainDate, geoLocation: GeoLocation, zenith: number, adjustForElevation: boolean): number;
     /**
      * A utility method that will allow the calculation of a temporal (solar) hour based on the sunrise and sunset
      * passed as parameters to this method. An example of the use of this method would be the calculation of a
-     * non-elevation adjusted temporal hour by passing in {@link #getSeaLevelSunrise() sea level sunrise} and
-     * {@link #getSeaLevelSunset() sea level sunset} as parameters.
+     * non-elevation adjusted temporal hour by passing in {@link getSeaLevelSunrise() sea level sunrise} and
+     * {@link getSeaLevelSunset() sea level sunset} as parameters.
      *
      * @param {Temporal.ZonedDateTime | null} startOfDay
      *            The start of the day.
@@ -493,9 +483,9 @@ export declare class NOAACalculator {
      *            The end of the day.
      *
      * @return {number} the <code>long</code> millisecond length of the temporal hour. If the calculation can't be computed a
-     *         {@link Long#MIN_VALUE} will be returned. See detailed explanation on top of the page.
+     *         `NaN` will be returned. See detailed explanation on top of the page.
      *
-     * @see #getTemporalHour()
+     * @see getTemporalHour()
      */
     getTemporalHour(startOfDay?: Temporal.ZonedDateTime | null, endOfDay?: Temporal.ZonedDateTime | null): number;
     /**
@@ -650,8 +640,7 @@ export declare class NOAACalculator {
     private static getSunHourAngleAtSunrise;
     /**
      * Returns the <a href="http://en.wikipedia.org/wiki/Hour_angle">hour angle</a> of the sun at sunset for the
-     * latitude. TODO: use - {@link #getSunHourAngleAtSunrise(double, double, double)} implementation to avoid
-     * duplication of code.
+     * latitude.
      * @private
      * @param {number} lat
      *            the latitude of observer in degrees