Note: It is important to read the technical notes on top of the {@link AstronomicalCalculator} documentation * before using this code. *
I would like to thank Rabbi Yaakov Shakow, the * author of Luach Ikvei Hayom who spent a considerable amount of time reviewing, correcting and making suggestions on the * documentation in this library. *
true will
* keep the standard astronomical chatzos calculation, while setting it to false will use half of
* a solar day calculation for chatzos.
* @see #isUseAstronomicalChatzos()
* @see #setUseAstronomicalChatzos(boolean)
* @see #getChatzos()
* @see #getSunTransit()
* @see #getChatzosAsHalfDay()
* @see #useAstronomicalChatzosForOtherZmanim
*/
private useAstronomicalChatzos;
/**
* Is {@link #getSunTransit() astronomical chatzos} used for {@link #getChatzos()} for enhanced accuracy. For
* example, as the day lengthens, the second half of the day is longer than the first and astronomical chatzos
* would be a drop earlier than half of the time between sunrise and sunset.
*
* @todo In the future, if this is set to true, the following may change to enhance accuracy. {@link #getSofZmanShmaGRA()
* Sof zman Shma GRA} would be calculated as 3 shaos zmaniyos after sunrise, but the shaos
* zmaniyos would be calculated as a 6th of the time between sunrise and chatzos, as opposed to a 12th of the
* time between sunrise and sunset. {@link #getMinchaGedola() mincha gedola} will be calculated as half a
* shaah zmanis of afternoon hours (a 6th of the time between chatzos and sunset after astronomical
* chatzos as opposed to 6.5 shaos zmaniyos after sunrise. {@link #getPlagHamincha() Plag
* hamincha} would be calculated as 4.75 shaos zmaniyos after astronomical chatzos as opposed to 10.75
* shaos zmaniyos after sunrise. Etc.
*
* @return if the use of astronomical chatzos is active.
* @see #useAstronomicalChatzos
* @see #setUseAstronomicalChatzos(boolean)
* @see #getChatzos()
* @see #getSunTransit()
* @see #getChatzosAsHalfDay()
* @see #isUseAstronomicalChatzosForOtherZmanim()
*/
isUseAstronomicalChatzos(): boolean;
/**
* Sets if astronomical chatzos should be used in calculations of other zmanim for enhanced accuracy.
* @param useAstronomicalChatzos set to true to use astronomical in chatzos in zmanim calculations.
* @see #useAstronomicalChatzos
* @see #isUseAstronomicalChatzos()
* @see #getChatzos()
* @see #getSunTransit()
* @see #getChatzosAsHalfDay()
* @see #setUseAstronomicalChatzosForOtherZmanim(boolean)
*/
setUseAstronomicalChatzos(useAstronomicalChatzos: boolean): void;
/**
* Is astronomical chatzos used for zmanim calculations besides chatzos itself for enhanced
* accuracy. The default value of false will keep the standard start to end of day calculations, while setting
* it to true will use half of a solar day calculation for zmanim.
* @see #isUseAstronomicalChatzosForOtherZmanim()
* @see #setUseAstronomicalChatzosForOtherZmanim(boolean)
* @see #isUseAstronomicalChatzos()
* @see #setUseAstronomicalChatzos(boolean)
* @see #getChatzos()
*/
private useAstronomicalChatzosForOtherZmanim;
/**
* Is astronomical chatzos used for zmanim calculations besides chatzos itself for enhanced
* accuracy. For example, as the day is lengthening (as we approach spring season), the second half of the day is longer than
* the first and astronomical chatzos would be a drop earlier than half of the time between sunrise and sunset.
* Conversely, the second half of the day would be shorter in the autumn as the days start getting shorter.
*
* @todo In the future, if this is set to true, the following may change to enhance accuracy. {@link #getSofZmanShmaGRA()
* Sof zman Shma GRA} would be calculated as 3 shaos zmaniyos after sunrise, but the shaos
* zmaniyos would be calculated as a 6th of the time between sunrise and chatzos, as opposed to a 12th of the
* time between sunrise and sunset. {@link #getMinchaGedola() mincha gedola} will be calculated as half a
* shaah zmanis of afternoon hours (a 6th of the time between chatzos and sunset after astronomical
* chatzos as opposed to 6.5 shaos zmaniyos after sunrise. {@link #getPlagHamincha() Plag
* hamincha} would be calculated as 4.75 shaos zmaniyos after astronomical chatzos as opposed to 10.75
* shaos zmaniyos after sunrise. Etc.
*
* @return if the use of astronomical chatzos is active.
* @see #useAstronomicalChatzosForOtherZmanim
* @see #setUseAstronomicalChatzosForOtherZmanim(boolean)
* @see #useAstronomicalChatzos
* @see #setUseAstronomicalChatzos(boolean)
*/
isUseAstronomicalChatzosForOtherZmanim(): boolean;
/**
* Sets if astronomical chatzos should be used in calculations of other zmanim for enhanced accuracy.
* @param useAstronomicalChatzosForOtherZmanim set to true to use astronomical in chatzos in zmanim calculations.
* @see #useAstronomicalChatzos
* @see #isUseAstronomicalChatzos()
*/
setUseAstronomicalChatzosForOtherZmanim(useAstronomicalChatzosForOtherZmanim: boolean): void;
/**
* The zenith of 16.1° below geometric zenith (90°). This calculation is used for determining alos
* (dawn) and tzais (nightfall) in some opinions. It is based on the calculation that the time between dawn
* and sunrise (and sunset to nightfall) is 72 minutes, the time that is takes to walk 4 mil at 18 minutes a mil (Rambam and others). The sun's position below the horizon 72 minutes
* before {@link #getSunrise() sunrise} in Jerusalem around the equinox / equilux is
* 16.1° below {@link #GEOMETRIC_ZENITH geometric zenith}.
*
* @see #getAlosHashachar()
* @see ComplexZmanimCalendar#getAlos16Point1Degrees()
* @see ComplexZmanimCalendar#getTzais16Point1Degrees()
* @see ComplexZmanimCalendar#getSofZmanShmaMGA16Point1Degrees()
* @see ComplexZmanimCalendar#getSofZmanTfilaMGA16Point1Degrees()
* @see ComplexZmanimCalendar#getMinchaGedola16Point1Degrees()
* @see ComplexZmanimCalendar#getMinchaKetana16Point1Degrees()
* @see ComplexZmanimCalendar#getPlagHamincha16Point1Degrees()
* @see ComplexZmanimCalendar#getPlagAlos16Point1ToTzaisGeonim7Point083Degrees()
* @see ComplexZmanimCalendar#getSofZmanShmaAlos16Point1ToSunset()
*/
protected static readonly ZENITH_16_POINT_1: number;
/**
* The zenith of 8.5° below geometric zenith (90°). This calculation is used for calculating alos
* (dawn) and tzais (nightfall) in some opinions. This calculation is based on the sun's position below the
* horizon 36 minutes after {@link #getSunset() sunset} in Jerusalem around the equinox / equilux, which
* is 8.5° below {@link #GEOMETRIC_ZENITH geometric zenith}. The Ohr Meir considers this the time that 3 small stars are visible,
* which is later than the required 3 medium stars.
*
* @see #getTzais()
* @see ComplexZmanimCalendar#getTzaisGeonim8Point5Degrees()
*/
protected static readonly ZENITH_8_POINT_5: number;
/**
* The default Shabbos candle lighting offset is 18 minutes. This can be changed via the
* {@link #setCandleLightingOffset(double)} and retrieved by the {@link #getCandleLightingOffset()}.
*/
private candleLightingOffset;
/**
* This method will return {@link #getSeaLevelSunrise() sea level sunrise} if {@link #isUseElevation()} is false (the
* default), or elevation adjusted {@link AstronomicalCalendar#getSunrise()} if it is true. This allows relevant zmanim
* in this and extending classes (such as the {@link ComplexZmanimCalendar}) to automatically adjust to the elevation setting.
*
* @return {@link #getSeaLevelSunrise()} if {@link #isUseElevation()} is false (the default), or elevation adjusted
* {@link AstronomicalCalendar#getSunrise()} if it is true.
* @see com.kosherjava.zmanim.AstronomicalCalendar#getSunrise()
*/
protected getElevationAdjustedSunrise(): DateTime | null;
/**
* This method will return {@link #getSeaLevelSunrise() sea level sunrise} if {@link #isUseElevation()} is false (the default),
* or elevation adjusted {@link AstronomicalCalendar#getSunrise()} if it is true. This allows relevant zmanim
* in this and extending classes (such as the {@link ComplexZmanimCalendar}) to automatically adjust to the elevation setting.
*
* @return {@link #getSeaLevelSunset()} if {@link #isUseElevation()} is false (the default), or elevation adjusted
* {@link AstronomicalCalendar#getSunset()} if it is true.
* @see AstronomicalCalendar#getSunset()
*/
protected getElevationAdjustedSunset(): DateTime | null;
/**
* A method that returns tzais (nightfall) when the sun is {@link #ZENITH_8_POINT_5 8.5°} below the
* {@link #GEOMETRIC_ZENITH geometric horizon} (90°) after {@link #getSunset() sunset}, a time that Rabbi Meir
* Posen in his the Ohr Meir calculated that 3 small
* stars are visible, which is later than the required 3 medium stars. See the {@link #ZENITH_8_POINT_5} constant.
*
* @see #ZENITH_8_POINT_5
*
* @return The Date of nightfall. If the calculation can't be computed such as northern and southern
* locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach
* low enough below the horizon for this calculation, a null will be returned. See detailed
* explanation on top of the {@link AstronomicalCalendar} documentation.
* @see #ZENITH_8_POINT_5
* ComplexZmanimCalendar#getTzaisGeonim8Point5Degrees() that returns an identical time to this generic tzais
*/
getTzais(): DateTime | null;
/**
* Returns alos (dawn) based on the time when the sun is {@link #ZENITH_16_POINT_1 16.1°} below the
* eastern {@link #GEOMETRIC_ZENITH geometric horizon} before {@link #getSunrise() sunrise}. This is based on the
* calculation that the time between dawn and sunrise (and sunset to nightfall) is 72 minutes, the time that is
* takes to walk 4 mil at
* 18 minutes a mil (Rambam and others). The sun's position
* below the horizon 72 minutes before {@link #getSunrise() sunrise} in Jerusalem on the around the equinox / equilux is
* 16.1° below {@link #GEOMETRIC_ZENITH}.
*
* @see #ZENITH_16_POINT_1
* @see ComplexZmanimCalendar#getAlos16Point1Degrees()
*
* @return The Date of dawn. If the calculation can't be computed such as northern and southern
* locations even south of the Arctic Circle and north of the Antarctic Circle where the sun may not reach
* low enough below the horizon for this calculation, a null will be returned. See detailed
* explanation on top of the {@link AstronomicalCalendar} documentation.
*/
getAlosHashachar(): DateTime | null;
/**
* Method to return alos (dawn) calculated as 72 minutes before {@link #getSunrise() sunrise} or
* {@link #getSeaLevelSunrise() sea level sunrise} (depending on the {@link #isUseElevation()} setting). This time
* is based on the time to walk the distance of 4 mil at 18 minutes a mil. The
* 72-minute time (but not the concept of fixed minutes) is based on the opinion that the time of the Neshef
* (twilight between dawn and sunrise) does not vary by the time of year or location but depends on the time it takes
* to walk the distance of 4 mil.
*
* @return the Date representing the 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 {@link AstronomicalCalendar}
* documentation.
*/
getAlos72(): DateTime | null;
/**
* This method returns {@link #getSunTransit() Astronomical chatzos} if the
* {@link com.kosherjava.zmanim.util.AstronomicalCalculator calculator} class used supports it and
* {@link #isUseAstronomicalChatzos() isUseAstronomicalChatzos()} is set to true or the {@link #getChatzosAsHalfDay()
* halfway point between sunrise and sunset} if it does not support it or it is not configured to use it. There are currently
* two {@link com.kosherjava.zmanim.util.AstronomicalCalculator calculators} available in the API, the default {@link
* com.kosherjava.zmanim.util.NOAACalculator NOAA calculator} and the {@link com.kosherjava.zmanim.util.SunTimesCalculator USNO
* calculator}. The USNO calculator calculates chatzos as halfway between sunrise and sunset (identical to six shaos
* zmaniyos after sunrise), while the NOAACalculator calculates it more accurately as {@link #getSunTransit() astronomical
* chatzos}. See The Definition of Chatzos
* for a detailed explanation of the ways to calculate Chatzos. Since half-day chatzos can be null in
* the Arctic on a day when either sunrise or sunset did not happen and astronomical chatzos can be calculated even in the
* Arctic, if half-day chatzos calculates as null and astronomical chatzos is supported by the
* calculator, astronomical chatzos will be returned to avoid returning a null.
*
* @see AstronomicalCalendar#getSunTransit()
* @see #getChatzosAsHalfDay()
* @see #isUseAstronomicalChatzos()
* @see #setUseAstronomicalChatzos(boolean)
* @return the Date of chatzos. If the calculation can't be computed such as in the Arctic Circle
* where there is at least one day where the sun does not rise, and one where it does not set, and the calculator does not
* support astronomical calculations (that will never report a null) a null will be returned.
* See detailed explanation on top of the {@link AstronomicalCalendar} documentation.
*/
getChatzos(): DateTime | null;
/**
* Returns chatzos calculated as halfway between sunrise and sunset. Many are of the opinion that
* chatzos is calculated as the midpoint between {@link #getSeaLevelSunrise() sea level sunrise} and
* {@link #getSeaLevelSunset() sea level sunset}, despite it not being the most accurate way to calculate it. A day
* starting at alos and ending at tzais using the same time or degree offset will also return
* the same time. In reality due to lengthening or shortening of day, this is not necessarily the exact midpoint of
* the day, but it is very close. This method allows you to use the NOAACalculator and still calculate chatzos
* as six shaos zmaniyos after sunrise. There are currently two {@link
* com.kosherjava.zmanim.util.AstronomicalCalculator calculators} available in the API, the {@link
* com.kosherjava.zmanim.util.NOAACalculator} and the {@link com.kosherjava.zmanim.util.SunTimesCalculator}.
* The SunTimesCalculator calculates chatzos as halfway between sunrise and sunset (and of six shaos
* zmaniyos), while the NOAACalculator calculates it as astronomical chatzos that is slightly more
* accurate. This method allows you to use the NOAACalculator and still calculate chatzos as six shaos
* zmaniyos after sunrise. See The Definition
* of Chatzos for a detailed explanation of the ways to calculate Chatzos.
*
* @see com.kosherjava.zmanim.util.NOAACalculator#getUTCNoon(Calendar, GeoLocation)
* @see com.kosherjava.zmanim.util.SunTimesCalculator#getUTCNoon(Calendar, GeoLocation)
* @see com.kosherjava.zmanim.util.AstronomicalCalculator#getUTCNoon(Calendar, GeoLocation)
* @see AstronomicalCalendar#getSunTransit(Date, Date)
* @see #getChatzos()
* @see #getSunTransit()
* @see #isUseAstronomicalChatzos()
*
* @return the Date of the latest chatzos. 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
* {@link AstronomicalCalendar} documentation.
*/
getChatzosAsHalfDay(): DateTime | null;
/**
* A generic method for calculating the latest zman krias shema (time to recite shema in the morning) that is 3 *
* shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and end of the day passed
* to this method. The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal
* hours), and the latest zman krias shema is calculated as 3 of those shaos zmaniyos after the beginning of
* the day. If {@link #isUseAstronomicalChatzosForOtherZmanim()} is true, the 3 shaos zmaniyos will be
* based on 1/6 of the time between sunrise and {@link #getSunTransit() astronomical chatzos}. As an example, passing
* {@link #getSunrise() sunrise} and {@link #getSunset() sunset} or {@link #getSeaLevelSunrise() sea level sunrise} and {@link
* #getSeaLevelSunset() sea level sunset} to this method (or {@link #getElevationAdjustedSunrise()} and {@link
* #getElevationAdjustedSunset()} that is driven off the {@link #isUseElevation()} setting) will return sof zman krias
* shema according to the opinion of the GRA. In cases
* where the start and end dates are not synchronous such as in {@link ComplexZmanimCalendar
* #getSofZmanShmaAlos16Point1ToTzaisGeonim7Point083Degrees()} false should be passed to the synchronous parameter
* to ensure that {@link #isUseAstronomicalChatzosForOtherZmanim()} will not be used.
*
* @param startOfDay
* the start of day for calculating zman krias shema. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating zman krias shema. This can be sunset or any tzais passed to
* this method.
* @param synchronous
* If the zman has a synchronous start and end of the day. If this is false, using a {@link
* #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @see #isUseAstronomicalChatzosForOtherZmanim()
* @return the Date of the latest zman shema based on the start and end of day times passed to this
* method. 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 {@link AstronomicalCalendar} documentation.
*/
getSofZmanShma(startOfDay: DateTime | null, endOfDay: DateTime | null, synchronous?: boolean): DateTime | null;
/**
* A generic method for calculating the latest zman krias shema that calls {@link #getSofZmanShma(Date, Date, boolean)}
* passing false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating zman krias shema. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating zman krias shema. This can be sunset or any tzais passed to
* this method.
* @return the Date of the latest zman shema based on the start and end of day times passed to this
* method. 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 {@link AstronomicalCalendar} documentation.
* @see #getSofZmanShma(Date, Date, boolean)
*/
/**
* This method returns the latest zman krias shema (time to recite shema in the morning) that is 3 *
* {@link #getShaahZmanisGra() shaos zmaniyos} (solar hours) after {@link #getSunrise() sunrise} or
* {@link #getSeaLevelSunrise() sea level sunrise} (depending on the {@link #isUseElevation()} setting), according
* to the GRA.
* The day is calculated from {@link #getSeaLevelSunrise() sea level sunrise} to {@link #getSeaLevelSunset() sea level
* sunset} or from {@link #getSunrise() sunrise} to {@link #getSunset() sunset} (depending on the
* {@link #isUseElevation()} setting).
*
* @see #getSofZmanShma(Date, Date)
* @see #getShaahZmanisGra()
* @see #isUseElevation()
* @see ComplexZmanimCalendar#getSofZmanShmaBaalHatanya()
* @return the Date of the latest zman shema according to the GRA. 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 the detailed explanation on top
* of the {@link AstronomicalCalendar} documentation.
*/
getSofZmanShmaGRA(): DateTime | null;
/**
* This method returns the latest zman krias shema (time to recite shema in the morning) that is 3 *
* {@link #getShaahZmanisMGA() shaos zmaniyos} (solar hours) after {@link #getAlos72()}, according to the
* Magen Avraham (MGA). The day is calculated
* from 72 minutes before {@link #getSeaLevelSunrise() sea level sunrise} to 72 minutes after {@link
* #getSeaLevelSunset() sea level sunset} or from 72 minutes before {@link #getSunrise() sunrise} to {@link #getSunset()
* sunset} (depending on the {@link #isUseElevation()} setting).
*
* @return the Date of the latest zman shema. 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
* {@link AstronomicalCalendar} documentation.
* @see #getSofZmanShma(Date, Date)
* @see ComplexZmanimCalendar#getShaahZmanis72Minutes()
* @see ComplexZmanimCalendar#getAlos72()
* @see ComplexZmanimCalendar#getSofZmanShmaMGA72Minutes()
*/
getSofZmanShmaMGA(): DateTime | null;
/**
* This method returns the tzais (nightfall) based on the opinion of Rabbeinu Tam that
* tzais hakochavim is calculated as 72 minutes after sunset, the time it takes to walk 4 mil at 18 minutes a mil.
* According to the Machtzis Hashekel in Orach Chaim
* 235:3, the Pri Megadim in Orach
* Chaim 261:2 (see the Biur Halacha) and others (see Hazmanim Bahalacha 17:3 and 17:5) the 72 minutes are standard
* clock minutes any time of the year in any location. Depending on the {@link #isUseElevation()} setting, a 72-minute
* offset from either {@link #getSunset() sunset} or {@link #getSeaLevelSunset() sea level sunset} is used.
*
* @see ComplexZmanimCalendar#getTzais16Point1Degrees()
* @return the Date representing 72 minutes after sunset. 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
* {@link AstronomicalCalendar} documentation.
*/
getTzais72(): DateTime | null;
/**
* A method to return candle lighting time, calculated as {@link #getCandleLightingOffset()} minutes before
* {@link #getSeaLevelSunset() sea level sunset}. This will return the time for any day of the week, since it can be
* used to calculate candle lighting time for Yom Tov (mid-week holidays) as well. Elevation adjustments
* are intentionally not performed by this method, but you can calculate it by passing the elevation adjusted sunset
* to {@link #getTimeOffset(Date, long)}.
*
* @return candle lighting 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 {@link AstronomicalCalendar} documentation.
*
* @see #getSeaLevelSunset()
* @see #getCandleLightingOffset()
* @see #setCandleLightingOffset(double)
*/
getCandleLighting(): DateTime | null;
/**
* A generic method for calculating the latest zman tfilah (time to recite the morning prayers)
* that is 4 * shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and
* end of the day passed to this method.
* The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal hours),
* and sof zman tfila is calculated as 4 of those shaos zmaniyos after the beginning of the day.
* As an example, passing {@link #getSunrise() sunrise} and {@link #getSunset() sunset} or {@link #getSeaLevelSunrise()
* sea level sunrise} and {@link #getSeaLevelSunset() sea level sunset} (depending on the {@link #isUseElevation()}
* elevation setting) to this method will return zman tfilah according to the opinion of the GRA. This method's synchronous parameter indicates if the start
* and end of day for the calculation are synchronous, having the same offset. This is typically the case, but some
* zmanim calculations are based on a start and end at different offsets from the real start and end of the day,
* such as starting the day at alos and an ending it at tzais Geonim or some other variant. If the day
* is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based calculations} will be bypassed.
* It would be illogical to use a half-day based calculation that start/end at chatzos when the two "halves" of
* the day are not equal, and the halfway point between them is not at chatzos.
*
* @param startOfDay
* the start of day for calculating zman tfilah. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating zman tfilah. This can be sunset or any tzais passed
* to this method.
* @param synchronous
* If the zman has a synchronous start and end of the day. If this is false, using a {@link
* #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the latest zman tfilah based on the start and end of day times passed
* to this method. 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 {@link AstronomicalCalendar} documentation.
*/
getSofZmanTfila(startOfDay: DateTime | null, endOfDay: DateTime | null, synchronous?: boolean): DateTime | null;
/**
* A generic method for calculating the latest zman tfila that calls {@link #getSofZmanTfila(Date, Date, boolean)}
* passing false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating zman tfilah. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating zman tfilah. This can be sunset or any tzais passed to
* this method.
* @return the Date of the latest zman tfilah based on the start and end of day times passed to this
* method. 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 {@link AstronomicalCalendar} documentation.
* @see #getSofZmanShma(Date, Date, boolean)
*/
/**
* This method returns the latest zman tfila (time to recite shema in the morning) that is 4 *
* {@link #getShaahZmanisGra() shaos zmaniyos }(solar hours) after {@link #getSunrise() sunrise} or
* {@link #getSeaLevelSunrise() sea level sunrise} (depending on the {@link #isUseElevation()} setting), according
* to the GRA.
* The day is calculated from {@link #getSeaLevelSunrise() sea level sunrise} to {@link #getSeaLevelSunset() sea level
* sunset} or from {@link #getSunrise() sunrise} to {@link #getSunset() sunset} (depending on the
* {@link #isUseElevation()} setting).
*
* @see #getSofZmanTfila(Date, Date)
* @see #getShaahZmanisGra()
* @see ComplexZmanimCalendar#getSofZmanTfilaBaalHatanya()
* @return the Date of the latest zman tfilah. 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
* {@link AstronomicalCalendar} documentation.
*/
getSofZmanTfilaGRA(): DateTime | null;
/**
* This method returns the latest zman tfila (time to recite shema in the morning) that is 4 *
* {@link #getShaahZmanisMGA() shaos zmaniyos} (solar hours) after {@link #getAlos72()}, according to the
* Magen Avraham (MGA). The day is calculated
* from 72 minutes before {@link #getSeaLevelSunrise() sea level sunrise} to 72 minutes after {@link
* #getSeaLevelSunset() sea level sunset} or from 72 minutes before {@link #getSunrise() sunrise} to {@link #getSunset()
* sunset} (depending on the {@link #isUseElevation()} setting).
*
* @return the Date of the latest zman tfila. 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
* {@link AstronomicalCalendar} documentation.
* @see #getSofZmanTfila(Date, Date)
* @see #getShaahZmanisMGA()
* @see #getAlos72()
*/
getSofZmanTfilaMGA(): DateTime | null;
/**
* A generic method for calculating mincha gedola (the earliest time to recite the mincha prayers) that
* is 6.5 * shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and end of the
* day passed to this method. The time from the start of day to the end of day are divided into 12 shaos zmaniyos
* (temporal hours), and mincha gedola is calculated as 6.5 of those shaos zmaniyos after the beginning
* of the day. As an example, passing {@link #getSunrise() sunrise} and {@link #getSunset() sunset} or {@link
* #getSeaLevelSunrise() sea level sunrise} and {@link #getSeaLevelSunset() sea level sunset} (depending on the {@link
* #isUseElevation()} elevation setting) to this method will return mincha gedola according to the opinion of the
* GRA. Alternatively, this method uses {@link
* #isUseAstronomicalChatzosForOtherZmanim()} to control if the time is based on 6.5 shaos zmaniyos into the day
* mentioned above, or as half an hour zmaniyos based on the second half of the day after chatzos ({@link
* #getSunTransit() astronomical chatzos} if supported by the {@link AstronomicalCalculator calculator} and {@link
* #isUseAstronomicalChatzos() configured} or {@link #getChatzosAsHalfDay() chatzos as half a day} if not. This
* method's synchronous parameter indicates if the start and end of day for the calculation are synchronous, having the same
* offset. This is typically the case, but some zmanim calculations are based on a start and end at different offsets
* from the real start and end of the day, such as starting the day at alos and an ending it at tzais Geonim
* or some other variant. If the day is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based
* calculations} will be bypassed. It would be illogical to use a half-day based calculation that start/end at chatzos
* when the two "halves" of the day are not equal, and the halfway point between them is not at chatzos.
*
* @param startOfDay
* the start of day for calculating Mincha gedola. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating Mincha gedola. This can be sunset or any tzais passed
* to this method.
* @param synchronous
* If the zman has a synchronous start and end of the day. If this is false, using a {@link
* #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of Mincha gedola based on the start and end of day times
* passed to this method. 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 {@link AstronomicalCalendar} documentation.
* @see #getSunTransit()
* @see #getChatzosAsHalfDay()
* @see #getChatzos()
* @see #isUseAstronomicalChatzos()
* @see #isUseAstronomicalChatzosForOtherZmanim()
*/
getMinchaGedola(): DateTime | null;
getMinchaGedola(startOfDay: DateTime | null, endOfDay: DateTime | null, synchronous?: boolean): DateTime | null;
/**
* A generic method for calculating mincha gedola that calls {@link #getMinchaGedola(Date, Date, boolean)} passing
* false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more
* details.
* @param startOfDay
* the start of day for calculating Mincha gedola. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating Mincha gedola. This can be sunset or any tzais passed to
* this method.
* @return the Date of the latest Mincha gedola based on the start and end of day times passed to this
* method. 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 {@link AstronomicalCalendar} documentation.
* @see #getMinchaGedola(Date, Date, boolean)
*/
/**
* This method returns the latest mincha gedola,the earliest time one can pray mincha that is 6.5 *
* {@link #getShaahZmanisGra() shaos zmaniyos} (solar hours) after {@link #getSunrise() sunrise} or
* {@link #getSeaLevelSunrise() sea level sunrise} (depending on the {@link #isUseElevation()} setting), according
* to the GRA. Mincha gedola is the earliest
* time one can pray mincha. The Ramba"m is of the opinion that it is better to delay mincha until
* {@link #getMinchaKetana() mincha ketana} while the Ra"sh, Tur, GRA and others are of the
* opinion that mincha can be prayed lechatchila starting at mincha gedola.
* The day is calculated from {@link #getSeaLevelSunrise() sea level sunrise} to {@link #getSeaLevelSunset() sea level
* sunset} or from {@link #getSunrise() sunrise} to {@link #getSunset() sunset} (depending on the {@link #isUseElevation()}
* setting).
* @todo Consider adjusting this to calculate the time as half an hour zmaniyos after either {@link
* #getSunTransit() astronomical chatzos} or {@link #getChatzosAsHalfDay() chatzos as half a day}
* for {@link AstronomicalCalculator calculators} that support it, based on {@link #isUseAstronomicalChatzos()}.
*
* @see #getMinchaGedola(Date, Date)
* @see #getShaahZmanisGra()
* @see #getMinchaKetana()
* @see ComplexZmanimCalendar#getMinchaGedolaBaalHatanya()
* @return the Date of the time of mincha gedola. 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
* {@link AstronomicalCalendar} documentation.
*/
/**
* A generic method for calculating samuch lemincha ketana, / near mincha ketana time that is half
* an hour before {@link #getMinchaKetana(Date, Date)} or 9 * shaos zmaniyos (temporal hours) after the
* start of the day, calculated using the start and end of the day passed to this method.
* The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal hours), and
* samuch lemincha ketana is calculated as 9 of those shaos zmaniyos after the beginning of the day.
* For example, passing {@link #getSunrise() sunrise} and {@link #getSunset() sunset} or {@link #getSeaLevelSunrise() sea
* level sunrise} and {@link #getSeaLevelSunset() sea level sunset} (depending on the {@link #isUseElevation()} elevation
* setting) to this method will return samuch lemincha ketana according to the opinion of the
* GRA. See the Mechaber and Mishna Berurah 232 and 249:2.
*
* @param startOfDay
* the start of day for calculating samuch lemincha ketana. This can be sunrise or any alos
* passed to this method.
* @param endOfDay
* the end of day for calculating samuch lemincha ketana. This can be sunset or any tzais
* passed to this method.
* @param synchronous
* If the zman has a synchronous start and end of the day. If this is false, using a {@link
* #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of Mincha ketana based on the start and end of day times
* passed to this method. 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 {@link AstronomicalCalendar} documentation.
*
* @see ComplexZmanimCalendar#getSamuchLeMinchaKetanaGRA()
* @see ComplexZmanimCalendar#getSamuchLeMinchaKetana16Point1Degrees()
* @see ComplexZmanimCalendar#getSamuchLeMinchaKetana72Minutes()
*/
getSamuchLeMinchaKetana(startOfDay: DateTime | null, endOfDay: DateTime | null, synchronous?: boolean): DateTime | null;
/**
* A generic method for calculating samuch lemincha ketana that calls {@link #getSamuchLeMinchaKetana(Date, Date, boolean)}
* passing false to the synchronous parameter since there is no way to know if the start and end of the day are
* synchronous. Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating samuch lemincha ketana. This can be sunrise or any alos
* passed to this method.
* @param endOfDay
* the end of day for calculating samuch lemincha ketana. This can be sunset or any tzais
* passed to this method.
* @return the Date of the time of samuch lemincha ketana based on the start and end of day times
* passed to this method. 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 {@link AstronomicalCalendar} documentation.
* @see #getSamuchLeMinchaKetana(Date, Date, boolean)
*/
/**
* A generic method for calculating mincha ketana, (the preferred time to recite the mincha prayers in
* the opinion of the Rambam and others) that is
* 9.5 * shaos zmaniyos (temporal hours) after the start of the day, calculated using the start and end
* of the day passed to this method.
* The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal hours), and
* mincha ketana is calculated as 9.5 of those shaos zmaniyos after the beginning of the day. As an
* example, passing {@link #getSunrise() sunrise} and {@link #getSunset() sunset} or {@link #getSeaLevelSunrise() sea
* level sunrise} and {@link #getSeaLevelSunset() sea level sunset} (depending on the {@link #isUseElevation()}
* elevation setting) to this method will return mincha ketana according to the opinion of the
* GRA. This method's synchronous parameter indicates if the start
* and end of day for the calculation are synchronous, having the same offset. This is typically the case, but some
* zmanim calculations are based on a start and end at different offsets from the real start and end of the day,
* such as starting the day at alos and an ending it at tzais Geonim or some other variant. If the day
* is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based calculations} will be bypassed.
* It would be illogical to use a half-day based calculation that start/end at chatzos when the two "halves" of
* the day are not equal, and the halfway point between them is not at chatzos.
*
* @param startOfDay
* the start of day for calculating Mincha ketana. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating Mincha ketana. This can be sunset or any tzais passed to
* this method.
* @param synchronous
* If the zman has a synchronous start and end of the day. If this is false, using a {@link
* #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of Mincha ketana based on the start and end of day times
* passed to this method. 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 {@link AstronomicalCalendar} documentation.
*/
getMinchaKetana(startOfDay: DateTime | null, endOfDay: DateTime | null, synchronous?: boolean): DateTime | null;
/**
* A generic method for calculating mincha ketana that calls {@link #getMinchaKetana(Date, Date, boolean)} passing
* false to the synchronous parameter since there is no way to know if the start and end of the day are synchronous.
* Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating Mincha ketana. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating Mincha ketana. This can be sunset or any tzais passed to
* this method.
* @return the Date of the time of Mincha ketana based on the start and end of day times
* passed to this method. 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 {@link AstronomicalCalendar} documentation.
* @see #getMinchaKetana(Date, Date, boolean)
*/
/**
* This method returns mincha ketana,the preferred earliest time to pray mincha in the
* opinion of the Rambam and others, that is 9.5
* {@link #getShaahZmanisGra() shaos zmaniyos} (solar hours) after {@link #getSunrise() sunrise} or
* {@link #getSeaLevelSunrise() sea level sunrise} (depending on the {@link #isUseElevation()} setting), according
* to the GRA. For more information on this see the
* documentation on {@link #getMinchaGedola() mincha gedola}.
* The day is calculated from {@link #getSeaLevelSunrise() sea level sunrise} to {@link #getSeaLevelSunset() sea level
* sunset} or from {@link #getSunrise() sunrise} to {@link #getSunset() sunset} (depending on the {@link #isUseElevation()}
* setting).
*
* @see #getMinchaKetana(Date, Date)
* @see #getShaahZmanisGra()
* @see #getMinchaGedola()
* @see ComplexZmanimCalendar#getMinchaKetanaBaalHatanya()
* @return the Date of the time of mincha ketana. 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
* {@link AstronomicalCalendar} documentation.
*/
/**
* A generic method for calculating plag hamincha (the earliest time that Shabbos can be started) that is
* 10.75 hours after the start of the day, (or 1.25 hours before the end of the day) based on the start and end of
* the day passed to the method.
* The time from the start of day to the end of day are divided into 12 shaos zmaniyos (temporal hours), and
* plag hamincha is calculated as 10.75 of those shaos zmaniyos after the beginning of the day. As an
* example, passing {@link #getSunrise() sunrise} and {@link #getSunset() sunset} or {@link #getSeaLevelSunrise() sea level
* sunrise} and {@link #getSeaLevelSunset() sea level sunset} (depending on the {@link #isUseElevation()} elevation
* setting) to this method will return plag mincha according to the opinion of the
* GRA. This method's synchronous parameter indicates if the start
* and end of day for the calculation are synchronous, having the same offset. This is typically the case, but some
* zmanim calculations are based on a start and end at different offsets from the real start and end of the day,
* such as starting the day at alos and an ending it at tzais Geonim or some other variant. If the day
* is not synchronous a {@link #getHalfDayBasedZman(Date, Date, double) half-day based calculations} will be bypassed. It
* would be illogical to use a half-day based calculation that start/end at chatzos when the two "halves" of the
* day are not equal, and the halfway point between them is not at chatzos.
*
* @param startOfDay
* the start of day for calculating plag hamincha. This can be sunrise or any alos passed to this method.
* @param endOfDay
* the end of day for calculating plag hamincha. This can be sunset or any tzais passed to this method.
* @param synchronous
* If the zman has a synchronous start and end of the day. If this is false, using a {@link
* #isUseAstronomicalChatzosForOtherZmanim()} makes no sense and will be ignored even if set to true, since by
* definition chatzos will not be the middle of the day for the zman.
* @return the Date of the time of plag hamincha based on the start and end of day times
* passed to this method. 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 {@link AstronomicalCalendar} documentation.
*/
getPlagHamincha(startOfDay: DateTime | null, endOfDay: DateTime | null, synchronous?: boolean): DateTime | null;
/**
* A generic method for calculating plag hamincha that calls {@link #getPlagHamincha(Date, Date, boolean)} passing
* false to the synchronous parameter since there is no way to know if the start and end of the day are synchronous.
* Passing true when they are not synchronous is too much of a risk. See information on that method for more details.
* @param startOfDay
* the start of day for calculating plag hamincha. This can be sunrise or any alos passed to this method.
* @param endOfDay
* the end of day for calculating plag hamincha. This can be sunset or any tzais passed to this method.
* @return the Date of the time of plag hamincha based on the start and end of day times
* passed to this method. 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 {@link AstronomicalCalendar} documentation.
* @see #getPlagHamincha(Date, Date, boolean)
*/
/**
* This method returns plag hamincha, that is 10.75 * {@link #getShaahZmanisGra() shaos zmaniyos}
* (solar hours) after {@link #getSunrise() sunrise} or {@link #getSeaLevelSunrise() sea level sunrise} (depending on
* the {@link #isUseElevation()} setting), according to the GRA. Plag hamincha is the earliest time that Shabbos can be started.
* The day is calculated from {@link #getSeaLevelSunrise() sea level sunrise} to {@link #getSeaLevelSunset() sea level
* sunset} or from {@link #getSunrise() sunrise} to {@link #getSunset() sunset} (depending on the {@link #isUseElevation()}
* setting).
*
* @see #getPlagHamincha(Date, Date)
* @see ComplexZmanimCalendar#getPlagHaminchaBaalHatanya()
* @return the Date of the time of plag hamincha. 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
* {@link AstronomicalCalendar} documentation.
*/
/**
* A method that returns a shaah zmanis ({@link #getTemporalHour(Date, Date) temporal hour}) according to
* the opinion of the GRA. This calculation divides the day
* based on the opinion of the GRA that the day runs from from {@link #getSeaLevelSunrise() sea level
* sunrise} to {@link #getSeaLevelSunset() sea level sunset} or {@link #getSunrise() sunrise} to {@link #getSunset()
* sunset} (depending on the {@link #isUseElevation()} setting). The day is split into 12 equal parts with each one
* being a shaah zmanis. This method is similar to {@link #getTemporalHour()}, but can account for elevation.
*
* @return the long millisecond length of a shaah zmanis calculated from sunrise to sunset.
* 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 Long#MIN_VALUE} will be returned. See
* detailed explanation on top of the {@link AstronomicalCalendar} documentation.
* @see #getTemporalHour(Date, Date)
* @see #getSeaLevelSunrise()
* @see #getSeaLevelSunset()
* @see ComplexZmanimCalendar#getShaahZmanisBaalHatanya()
*/
getShaahZmanisGra(): number;
/**
* A method that returns a shaah zmanis (temporal hour) according to the opinion of the Magen Avraham (MGA) based on a 72-minute alos
* and tzais. This calculation divides the day that runs from dawn to dusk (for sof zman krias shema and
* tfila). Dawn for this calculation is 72 minutes before {@link #getSunrise() sunrise} or {@link #getSeaLevelSunrise()
* sea level sunrise} (depending on the {@link #isUseElevation()} elevation setting) and dusk is 72 minutes after {@link
* #getSunset() sunset} or {@link #getSeaLevelSunset() sea level sunset} (depending on the {@link #isUseElevation()} elevation
* setting). This day is split into 12 equal parts with each part being a shaah zmanis. Alternate methods of calculating
* a shaah zmanis according to the Magen Avraham (MGA) are available in the subclass {@link ComplexZmanimCalendar}.
*
* @return the long millisecond length of a shaah zmanis. 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 Long#MIN_VALUE} will be returned. See detailed explanation on top of the
* {@link AstronomicalCalendar} documentation.
*/
getShaahZmanisMGA(): number;
/**
* Default constructor will set a default {@link GeoLocation#GeoLocation()}, a default
* {@link AstronomicalCalculator#getDefault() AstronomicalCalculator} and default the calendar to the current date.
*
* @see AstronomicalCalendar#AstronomicalCalendar()
*/
/**
* A constructor that takes a {@link GeoLocation} as a parameter.
*
* @param location
* the location
*/
/**
* A method to get the offset in minutes before {@link AstronomicalCalendar#getSeaLevelSunset() sea level sunset} which
* is used in calculating candle lighting time. The default time used is 18 minutes before sea level sunset. Some
* calendars use 15 minutes, while the custom in Jerusalem is to use a 40-minute offset. Please check the local custom
* for candle lighting time.
*
* @return Returns the currently set candle lighting offset in minutes.
* @see #getCandleLighting()
* @see #setCandleLightingOffset(double)
*/
getCandleLightingOffset(): number;
/**
* A method to set the offset in minutes before {@link AstronomicalCalendar#getSeaLevelSunset() sea level sunset} that is
* used in calculating candle lighting time. The default time used is 18 minutes before sunset. Some calendars use 15
* minutes, while the custom in Jerusalem is to use a 40-minute offset.
*
* @param candleLightingOffset
* The candle lighting offset to set in minutes.
* @see #getCandleLighting()
* @see #getCandleLightingOffset()
*/
setCandleLightingOffset(candleLightingOffset: number): void;
getClassName(): string;
/**
* This is a utility method to determine if the current Date (date-time) passed in has a melacha (work) prohibition.
* Since there are many opinions on the time of tzais, the tzais for the current day has to be passed to this
* class. Sunset is the classes current day's {@link #getElevationAdjustedSunset() elevation adjusted sunset} that observes the
* {@link #isUseElevation()} settings. The {@link JewishCalendar#getInIsrael()} will be set by the inIsrael parameter.
*
* @param currentTime the current time
* @param tzais the time of tzais
* @param inIsrael whether to use Israel holiday scheme or not
*
* @return true if melacha is prohibited or false if it is not.
*
* @see JewishCalendar#isAssurBemelacha()
* @see JewishCalendar#hasCandleLighting()
* @see JewishCalendar#setInIsrael(boolean)
*/
isAssurBemlacha(currentTime: DateTime, tzais: DateTime, inIsrael: boolean): boolean;
/**
* A generic utility method for calculating any shaah zmanis (temporal hour) based zman with the
* day defined as the start and end of day (or night) and the number of shaahos zmaniyos passed to the
* method. This simplifies the code in other methods such as {@link #getPlagHamincha(Date, Date)} and cuts down on
* code replication. As an example, passing {@link #getSunrise() sunrise} and {@link #getSunset() sunset} or {@link
* #getSeaLevelSunrise() sea level sunrise} and {@link #getSeaLevelSunset() sea level sunset} (depending on the
* {@link #isUseElevation()} elevation setting) and 10.75 hours to this method will return plag mincha
* according to the opinion of the GRA.
*
* @param startOfDay
* the start of day for calculating the zman. This can be sunrise or any alos passed
* to this method.
* @param endOfDay
* the end of day for calculating the zman. This can be sunset or any tzais passed to
* this method.
* @param hours
* the number of shaahos zmaniyos (temporal hours) to offset from the start of day
* @return the Date of the time of zman with the shaahos zmaniyos (temporal hours)
* in the day offset from the start of day passed to this method. 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
* {@link AstronomicalCalendar} documentation.
*/
getShaahZmanisBasedZman(startOfDay: DateTime | null, endOfDay: DateTime | null, hours: number): DateTime | null;
/**
* A utility method that returns the percentage of a shaah zmanis after sunset (or before sunrise) for a given degree
* offset. For the equilux where there
* is a 720-minute day, passing 16.1° for the location of Jerusalem will return about 1.2. This will work for any location
* or date, but will typically only be of interest at the equinox/equilux to calculate the percentage of a shaah zmanis
* for those who want to use the Minchas Cohen in Ma'amar 2:4
* and the Pri Chadash who calculate tzais as a percentage
* of the day after sunset. While the Minchas Cohen only applies this to 72 minutes or a 1/10 of the day around the world (based
* on the equinox / equilux in Israel, this method allows calculations for any degree level for any location.
*
* @param degrees
* the number of degrees below the horizon after sunset.
* @param sunset
* if true the calculation should be degrees after sunset, or if false, degrees before sunrise.
* @return the double percentage of a sha'ah zmanis for a given set of degrees below the astronomical horizon
* for the current calendar. If the calculation can't be computed a {@link Double#MIN_VALUE} will be returned. See detailed
* explanation on top of the page.
*/
getPercentOfShaahZmanisFromDegrees(degrees: number, sunset: boolean): number;
/**
* A utility method to calculate zmanim based on Rav Moshe
* Feinstein and others as calculated in MTJ, Yeshiva of Staten Island, and Camp Yeshiva
* of Staten Island and other calendars. The day is split in two, from alos / sunrise to chatzos, and the
* second half of the day, from chatzos to sunset / tzais. Morning based times are calculated. based on the first
* 6 hours of the day, and afternoon times based on the second half of the day. As an example, passing 0.5, a start of
* chatzos and an end of day as sunset will return the time of mincha gedola GRA as half an hour zmanis
* based on the second half of the day. Some zmanim calculations can be based on subtracting shaos zmaniyos
* from the end of the day, and that is supported by passing a negative hour to this method.
*
* @param startOfHalfDay
* The start of the half day. This would be alos or sunrise for morning based times such as sof zman krias
* shema and chatzos for afternoon based times such as mincha gedola.
* @param endOfHalfDay
* The end of the half day. This would be chatzos for morning based times such as sof zman krias shema
* and sunset or tzais for afternoon based times such as mincha gedola.
* @param hours
* The number of shaos zmaniyos (hours) to offset the beginning of the first or second half of the day. For example,
* 3 for sof zman Shma, 0.5 for mincha gedola (half an hour after chatzos) and 4.75 for plag
* hamincha. If the number of hours is negative, it will subtract the number of shaos zmaniyos from the end
* of the day.
*
* @return the Date of zman based on calculation of the first or second half of the day. 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 {@link AstronomicalCalendar} documentation.
*
* @see ComplexZmanimCalendar#getFixedLocalChatzos()
*/
getHalfDayBasedZman(startOfHalfDay: DateTime | null, endOfHalfDay: DateTime | null, hours: number): DateTime | null;
/**
* A utility method to calculate the length of a sha'ah zmanis based on 1/6 of a 6-hour day.
* @param startOfHalfDay The start of the half-day. This would be alos or sunrise for the first half of the day,
* or chatzos for the second half of the day.
* @param endOfHalfDay The end of the half-day. This would be chatzos for the first half of the day, or sunset or
* tzais for the second half of the day.
* @return The long millisecond length of a shaah zmanis based on 1/6 of a half-day. 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 Long#MIN_VALUE} will be returned. See detailed explanation on top of the
* {@link AstronomicalCalendar} documentation.
* @see #getHalfDayBasedZman(Date, Date, double)
* @see #isUseAstronomicalChatzosForOtherZmanim()
* @todo Consider adjusting various shaah zmanis times to use this.
*/
getHalfDayBasedShaahZmanis(startOfHalfDay: DateTime | null, endOfHalfDay: DateTime | null): number;
}