@hebcal/noaa 0.8.4 → 0.8.5

package/dist/index.d.ts

@@ -10,28 +10,53 @@ import { Temporal } from 'temporal-polyfill';
  */
 export declare class GeoLocation {
     /**
+     * GeoLocation constructor with parameters for all required fields.
+     *
+     * @param {string} name
+     *            The location name for display use such as "Lakewood, NJ"
+     * @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 east of the <a href="http://en.wikipedia.org/wiki/Prime_Meridian">Prime
+     *            Meridian </a> (Greenwich), a negative value should be used.
+     * @param {number} elevation
+     *            the elevation above sea level in Meters. Elevation is not used in most algorithms used for calculating
+     *            sunrise and set.
+     * @param {string} timeZoneId
+     *            the <code>TimeZone</code> for the location.
+     */
+    constructor(name: string | null, latitude: number, longitude: number, elevation: number, timeZoneId?: string);
+    constructor(name: string | null, latitude: number, longitude: 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)
      */
@@ -39,58 +64,37 @@ export declare class GeoLocation {
     /**
      * Method to get the elevation in Meters.
      *
-     * @return Returns the elevation in Meters.
+     * @return {number} Returns the elevation in Meters.
      */
     getElevation(): number;
     /**
      * Method to set the elevation in Meters <b>above </b> sea level.
      *
-     * @param elevation
+     * @param {number} elevation
      *            The elevation to set in Meters. An IllegalArgumentException will be thrown if the value is a negative.
      */
     setElevation(elevation: number): void;
-    /**
-     * GeoLocation constructor with parameters for all required fields.
-     *
-     * @param name
-     *            The location name for display use such as &quot;Lakewood, NJ&quot;
-     * @param 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 longitude
-     *            double the longitude in a double format such as -74.222130 for Lakewood, NJ.
-     *            <b>Note: </b> For longitudes east of the <a href="http://en.wikipedia.org/wiki/Prime_Meridian">Prime
-     *            Meridian </a> (Greenwich), a negative value should be used.
-     * @param elevation
-     *            the elevation above sea level in Meters. Elevation is not used in most algorithms used for calculating
-     *            sunrise and set.
-     * @param timeZoneId
-     *            the <code>TimeZone</code> for the location.
-     */
-    constructor(name: string | null, latitude: number, longitude: number, elevation: number, timeZoneId?: string);
-    constructor(name: string | null, latitude: number, longitude: number, timeZoneId: string);
-    constructor();
     setLatitude(latitude: number): void;
     /**
-     * @return Returns the latitude.
+     * @return {number} Returns the latitude.
      */
     getLatitude(): number;
     setLongitude(longitude: number): void;
     /**
-     * @return Returns the longitude.
+     * @return {number} Returns the longitude.
      */
     getLongitude(): number;
     /**
-     * @return Returns the location name.
+     * @return {string|null} Returns the location name.
      */
     getLocationName(): string | null;
     /**
-     * @param name
+     * @param {string|null} name
      *            The setter method for the display name.
      */
     setLocationName(name: string | null): void;
     /**
-     * @return Returns the timeZone.
+     * @return {string} Returns the timeZone.
      */
     getTimeZone(): string;
     /**
@@ -101,7 +105,7 @@ export declare class GeoLocation {
      * AstronomicalCalendar to output times in the expected offset. This situation will arise if the
      * AstronomicalCalendar is ever {@link AstronomicalCalendar#clone() cloned}.
      *
-     * @param timeZone
+     * @param {string} timeZone
      *            The timeZone to set.
      */
     setTimeZone(timeZoneId: string): void;
@@ -120,6 +124,18 @@ export declare class GeoLocation {
  * @author &copy; Eliyahu Hershfeld 2011 - 2019
  */
 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}.
+     *
+     * @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);
     /**
      * The zenith of astronomical sunrise and sunset. The sun is 90&deg; from the vertical 0&deg;
      * @private
@@ -153,7 +169,7 @@ export declare class NOAACalculator {
      */
     private geoLocation;
     /**
-     * The getSunrise method Returns a <code>Date</code> representing the
+     * 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
@@ -161,7 +177,7 @@ export declare class NOAACalculator {
      * 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.
      *
-     * @return the <code>Date</code> representing the exact sunrise time. If the calculation can't be computed such as
+     * @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
@@ -175,7 +191,7 @@ export declare class NOAACalculator {
      * 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.
      *
-     * @return the <code>Date</code> representing the exact sea-level sunrise time. If the calculation can't be computed
+     * @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
@@ -186,7 +202,7 @@ export declare class NOAACalculator {
     /**
      * A method that returns the beginning of civil twilight (dawn) using a zenith of {@link #CIVIL_ZENITH 96&deg;}.
      *
-     * @return The <code>Date</code> of the beginning of civil twilight using a zenith of 96&deg;. If the calculation
+     * @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
      */
@@ -194,7 +210,7 @@ export declare class NOAACalculator {
     /**
      * A method that returns the beginning of nautical twilight using a zenith of {@link #NAUTICAL_ZENITH 102&deg;}.
      *
-     * @return The <code>Date</code> of the beginning of nautical twilight using a zenith of 102&deg;. If the
+     * @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
      */
@@ -203,13 +219,13 @@ export declare class NOAACalculator {
      * A method that returns the beginning of astronomical twilight using a zenith of {@link #ASTRONOMICAL_ZENITH
      * 108&deg;}.
      *
-     * @return The <code>Date</code> of the beginning of astronomical twilight using a zenith of 108&deg;. If the
+     * @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
      */
     getBeginAstronomicalTwilight(): Temporal.ZonedDateTime | null;
     /**
-     * The getSunset method Returns a <code>Date</code> representing the
+     * 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
@@ -220,7 +236,7 @@ export declare class NOAACalculator {
      * 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.
      *
-     * @return the <code>Date</code> representing the exact sunset time. If the calculation can't be computed such as in
+     * @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
@@ -234,7 +250,7 @@ export declare class NOAACalculator {
      * 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.
      *
-     * @return the <code>Date</code> representing the exact sea-level sunset time. If the calculation can't be computed
+     * @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
@@ -244,7 +260,7 @@ export declare class NOAACalculator {
     /**
      * A method that returns the end of civil twilight using a zenith of {@link #CIVIL_ZENITH 96&deg;}.
      *
-     * @return The <code>Date</code> 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
      */
@@ -252,7 +268,7 @@ export declare class NOAACalculator {
     /**
      * A method that returns the end of nautical twilight using a zenith of {@link #NAUTICAL_ZENITH 102&deg;}.
      *
-     * @return The <code>Date</code> 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
@@ -261,7 +277,7 @@ export declare class NOAACalculator {
     /**
      * A method that returns the end of astronomical twilight using a zenith of {@link #ASTRONOMICAL_ZENITH 108&deg;}.
      *
-     * @return the <code>Date</code> 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
@@ -273,11 +289,11 @@ export declare class NOAACalculator {
      * after sunset with the intent of getting a rough "level of light" calculation, the sunrise or sunset time passed
      * to this method should be sea level sunrise and sunset.
      *
-     * @param time
+     * @param {Temporal.ZonedDateTime | null} time
      *            the start time
-     * @param offset
+     * @param {number} offset
      *            the offset in milliseconds to add to the time.
-     * @return the {@link java.util.Date} with the offset in milliseconds added to it
+     * @return {Temporal.ZonedDateTime | null} the `Date` with the offset in milliseconds added to it
      */
     static getTimeOffset(time: Temporal.ZonedDateTime | null, offset: number): Temporal.ZonedDateTime | null;
     /**
@@ -285,12 +301,12 @@ export declare class NOAACalculator {
      * {@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 offsetZenith
+     * @param {number} offsetZenith
      *            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
      *            parameter.
-     * @return The {@link java.util.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.
@@ -301,34 +317,23 @@ export declare class NOAACalculator {
      * 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.
      *
-     * @param offsetZenith
+     * @param {number} offsetZenith
      *            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 The {@link java.util.Date}of the offset after (or before) {@link #getSunset()}. If the calculation can't
+     * @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.
      */
     getSunsetOffsetByDegrees(offsetZenith: number): Temporal.ZonedDateTime | null;
-    /**
-     * 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}.
-     *
-     * @param geoLocation
-     *            The location information used for calculating astronomical sun times.
-     *
-     * @see #setAstronomicalCalculator(AstronomicalCalculator) for changing the calculator class.
-     */
-    constructor(geoLocation: GeoLocation, date: Temporal.PlainDate);
     /**
      * A method that returns the sunrise in UTC time without correction for time zone offset from GMT and without using
      * daylight savings time.
      *
-     * @param zenith
+     * @param {number} zenith
      *            the degrees below the horizon. For time after sunrise use negative numbers.
-     * @return The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     * @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.
      */
@@ -339,9 +344,9 @@ export declare class NOAACalculator {
      * light, something that is not affected by elevation. This method returns UTC sunrise calculated at sea level. This
      * forms the base for dawn calculations that are calculated as a dip below the horizon before sunrise.
      *
-     * @param zenith
+     * @param {number} zenith
      *            the degrees below the horizon. For time after sunrise use negative numbers.
-     * @return The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     * @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
@@ -352,9 +357,9 @@ export declare class NOAACalculator {
      * A method that returns the sunset in UTC time without correction for time zone offset from GMT and without using
      * daylight savings time.
      *
-     * @param zenith
+     * @param {number} zenith
      *            the degrees below the horizon. For time after sunset use negative numbers.
-     * @return The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     * @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
@@ -367,9 +372,9 @@ export declare class NOAACalculator {
      * at sea level. This forms the base for dusk calculations that are calculated as a dip below the horizon after
      * sunset.
      *
-     * @param zenith
+     * @param {number} zenith
      *            the degrees below the horizon. For time before sunset use negative numbers.
-     * @return The time in the format: 18.75 for 18:45:00 UTC/GMT. If the calculation can't be computed such as in the
+     * @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
@@ -404,9 +409,9 @@ export declare class NOAACalculator {
      * elevationAdjustment = 0.0347 * Math.sqrt(elevationMeters);
      * </pre>
      *
-     * @param elevation
+     * @param {number} elevation
      *            elevation in Meters.
-     * @return the adjusted zenith
+     * @return {number} the adjusted zenith
      */
     getElevationAdjustment(elevation: number): number;
     /**
@@ -429,15 +434,15 @@ export declare class NOAACalculator {
      * {@link ZmanimCalendar#ZENITH_16_POINT_1 16.1&deg;} dip used in
      * {@link ComplexZmanimCalendar#getAlos16Point1Degrees()}.
      *
-     * @param zenith
+     * @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}
      *            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.
-     * @param elevation
+     * @param {number} elevation
      *            elevation in Meters.
-     * @return The zenith adjusted to include the {@link #getSolarRadius sun's radius}, {@link #getRefraction
+     * @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
      *         sunrise and sunset (if the zenith == 90&deg;)
      * @see #getElevationAdjustment(double)
@@ -467,17 +472,17 @@ export declare class NOAACalculator {
      * non-elevation adjusted temporal hour by passing in {@link #getSeaLevelSunrise() sea level sunrise} and
      * {@link #getSeaLevelSunset() sea level sunset} as parameters.
      *
-     * @param startOfday
+     * @param {Temporal.ZonedDateTime | null} startOfDay
      *            The start of the day.
-     * @param endOfDay
+     * @param {Temporal.ZonedDateTime | null} endOfDay
      *            The end of the day.
      *
-     * @return the <code>long</code> millisecond length of the temporal hour. If the calculation can't be computed a
+     * @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.
      *
      * @see #getTemporalHour()
      */
-    getTemporalHour(startOfday?: Temporal.ZonedDateTime | null, endOfDay?: Temporal.ZonedDateTime | null): number;
+    getTemporalHour(startOfDay?: Temporal.ZonedDateTime | null, endOfDay?: Temporal.ZonedDateTime | null): number;
     /**
      * A method that returns sundial or solar noon. It occurs when the Sun is <a href
      * ="http://en.wikipedia.org/wiki/Transit_%28astronomy%29">transiting</a> the <a
@@ -485,32 +490,32 @@ export declare class NOAACalculator {
      * calculated as halfway between the sunrise and sunset passed to this method. This time can be slightly off the
      * real transit time due to changes in declination (the lengthening or shortening day).
      *
-     * @param startOfDay
+     * @param {Temporal.ZonedDateTime | null} startOfDay
      *            the start of day for calculating the sun's transit. This can be sea level sunrise, visual sunrise (or
      *            any arbitrary start of day) passed to this method.
-     * @param endOfDay
+     * @param {Temporal.ZonedDateTime | null} endOfDay
      *            the end of day for calculating the sun's transit. This can be sea level sunset, visual sunset (or any
      *            arbitrary end of day) passed to this method.
      *
-     * @return the <code>Date</code> representing Sun's transit. If the calculation can't be computed such as in the
+     * @return {Temporal.ZonedDateTime | null} The `Date` representing Sun's transit. 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, null will be returned. See detailed explanation on top of the page.
      */
     getSunTransit(startOfDay?: Temporal.ZonedDateTime | null, endOfDay?: Temporal.ZonedDateTime | null): Temporal.ZonedDateTime | null;
     /**
-     * A method that returns a <code>Date</code> from the time passed in as a parameter.
+     * A method that returns a `Date` from the time passed in as a parameter.
      * @protected
-     * @param time
-     *            The time to be set as the time for the <code>Date</code>. The time expected is in the format: 18.75
+     * @param {number} time
+     *            The time to be set as the time for the `Date`. The time expected is in the format: 18.75
      *            for 6:45:00 PM.
-     * @param isSunrise true if the time is sunrise, and false if it is sunset
-     * @return The Date.
+     * @param {boolean} isSunrise true if the time is sunrise, and false if it is sunset
+     * @return {Temporal.ZonedDateTime | null} The Date.
      */
     protected getDateFromTime(time: number, isSunrise: boolean): Temporal.ZonedDateTime | null;
     /**
      * Return the <a href="http://en.wikipedia.org/wiki/Julian_day">Julian day</a> from a Java Calendar
      * @private
-     * @param calendar
+     * @param {Temporal.ZonedDateTime} date
      *            The Java Calendar
      * @return the Julian day corresponding to the date Note: Number is returned for start of day. Fractional days
      *         should be added later.
@@ -619,11 +624,11 @@ export declare class NOAACalculator {
      * Return the <a href="http://en.wikipedia.org/wiki/Hour_angle">hour angle</a> of the sun at sunrise for the
      * latitude.
      * @private
-     * @param lat
+     * @param {number} lat
      *            , the latitude of observer in degrees
      * @param solarDec
      *            the declination angle of sun in degrees
-     * @param zenith
+     * @param {number} zenith
      *            the zenith
      * @return hour angle of sunrise in radians
      */
@@ -633,11 +638,11 @@ export declare class NOAACalculator {
      * latitude. TODO: use - {@link #getSunHourAngleAtSunrise(double, double, double)} implementation to avoid
      * duplication of code.
      * @private
-     * @param lat
+     * @param {number} lat
      *            the latitude of observer in degrees
      * @param solarDec
      *            the declination angle of sun in degrees
-     * @param zenith
+     * @param {number} zenith
      *            the zenith
      * @return the hour angle of sunset in radians
      */
@@ -647,13 +652,13 @@ export declare class NOAACalculator {
      * horizontal coordinate system at the given location at the given time. Can be negative if the sun is below the
      * horizon. Not corrected for altitude.
      *
-     * @param cal
+     * @param {Temporal.ZonedDateTime} date
      *            time of calculation
-     * @param lat
+     * @param {number} lat
      *            latitude of location for calculation
-     * @param lon
+     * @param {number} lon
      *            longitude of location for calculation
-     * @return solar elevation in degrees - horizon is 0 degrees, civil twilight is -6 degrees
+     * @return {number} solar elevation in degrees - horizon is 0 degrees, civil twilight is -6 degrees
      */
     static getSolarElevation(date: Temporal.ZonedDateTime, lat: number, lon: number): number;
     /**
@@ -661,13 +666,13 @@ export declare class NOAACalculator {
      * horizontal coordinate system at the given location at the given time. Not corrected for altitude. True south is 0
      * degrees.
      *
-     * @param cal
+     * @param {Temporal.ZonedDateTime} date
      *            time of calculation
-     * @param latitude
+     * @param {number} latitude
      *            latitude of location for calculation
-     * @param lon
+     * @param {number} lon
      *            longitude of location for calculation
-     * @return FIXME
+     * @return {number}
      */
     static getSolarAzimuth(date: Temporal.ZonedDateTime, latitude: number, lon: number): number;
     /**
@@ -676,11 +681,11 @@ export declare class NOAACalculator {
      * @private
      * @param julianDay
      *            the Julian day
-     * @param latitude
+     * @param {number} latitude
      *            the latitude of observer in degrees
-     * @param longitude
+     * @param {number} longitude
      *            the longitude of observer in degrees
-     * @param zenith
+     * @param {number} zenith
      *            the zenith
      * @return the time in minutes from zero UTC
      */
@@ -692,7 +697,7 @@ export declare class NOAACalculator {
      * @private
      * @param julianCenturies
      *            the number of Julian centuries since J2000.0
-     * @param longitude
+     * @param {number} longitude
      *            the longitude of observer in degrees
      * @return the time in minutes from zero UTC
      */
@@ -703,11 +708,11 @@ export declare class NOAACalculator {
      * @private
      * @param julianDay
      *            the Julian day
-     * @param latitude
+     * @param {number} latitude
      *            the latitude of observer in degrees
-     * @param longitude
+     * @param {number} longitude
      *            : longitude of observer in degrees
-     * @param zenith
+     * @param {number} zenith
      *            the zenith
      * @return the time in minutes from zero Universal Coordinated Time (UTC)
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebcal/noaa",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "sunrise and sunset via NOAA algorithm with elevation, based on KosherJava",
   "author": "Michael J. Radwin (https://github.com/mjradwin)",
   "contributors": [