@hebcal/core 5.4.6 → 5.4.7

package/dist/core.d.ts

@@ -0,0 +1,1715 @@
+import { gematriya } from '@hebcal/hdate';
+import { gematriyaStrToNum } from '@hebcal/hdate';
+import { GeoLocation } from '@hebcal/noaa';
+import { greg } from '@hebcal/hdate';
+import { HDate } from '@hebcal/hdate';
+import { Locale } from '@hebcal/hdate';
+import { months } from '@hebcal/hdate';
+import { NOAACalculator } from '@hebcal/noaa';
+
+/**
+ * Because Asara B'Tevet often occurs twice in the same Gregorian year,
+ * we subclass HolidayEvent to override the `url()` method.
+ */
+export declare class AsaraBTevetEvent extends HolidayEvent {
+    /** @return {string} */
+    urlDateSuffix(): string;
+}
+
+/**
+ * Options to configure which events are returned
+ */
+export declare type CalOptions = {
+    /**
+     * latitude/longitude/tzid used for candle-lighting
+     */
+    location?: Location_2;
+    /**
+     * Gregorian or Hebrew year
+     */
+    year?: number;
+    /**
+     * to interpret year as Hebrew year
+     */
+    isHebrewYear?: boolean;
+    /**
+     * Gregorian or Hebrew month (to filter results to a single month)
+     */
+    month?: number | string;
+    /**
+     * generate calendar for multiple years (default 1)
+     */
+    numYears?: number;
+    /**
+     * use specific start date (requires end date)
+     */
+    start?: number | HDate | Date;
+    /**
+     * use specific end date (requires start date)
+     */
+    end?: number | HDate | Date;
+    /**
+     * calculate candle-lighting and havdalah times
+     */
+    candlelighting?: boolean;
+    /**
+     * minutes before sundown to light candles (default 18)
+     */
+    candleLightingMins?: number;
+    /**
+     * minutes after sundown for Havdalah (typical values are 42, 50, or 72).
+     * If `undefined` (the default), calculate Havdalah according to Tzeit Hakochavim -
+     * Nightfall (the point when 3 small stars are observable in the night time sky with
+     * the naked eye). If `0`, Havdalah times are suppressed.
+     */
+    havdalahMins?: number;
+    /**
+     * degrees for solar depression for Havdalah.
+     * Default is 8.5 degrees for 3 small stars. use 7.083 degrees for 3 medium-sized stars
+     * (observed by Dr. Baruch (Berthold) Cohn in his luach published in France in 1899).
+     * If `0`, Havdalah times are suppressed.
+     */
+    havdalahDeg?: number;
+    /**
+     * degrees for solar depression for end of fast days.
+     * Default is 7.083 degrees for 3 medium-sized stars. Other commonly-used values include
+     * 6.45 degrees, as calculated by Rabbi Yechiel Michel Tucazinsky.
+     */
+    fastEndDeg?: number;
+    /**
+     * use elevation for calculations (default `false`).
+     * If `true`, use elevation to affect the calculation of all sunrise/sunset based zmanim.
+     * Note: there are some zmanim such as degree-based zmanim that are driven by the amount
+     * of light in the sky and are not impacted by elevation.
+     * These zmanim intentionally do not support elevation adjustment.
+     */
+    useElevation?: boolean;
+    /**
+     * calculate parashah hashavua on Saturdays
+     */
+    sedrot?: boolean;
+    /**
+     * Israeli holiday and sedra schedule
+     */
+    il?: boolean;
+    /**
+     * suppress minor fasts
+     */
+    noMinorFast?: boolean;
+    /**
+     * suppress modern holidays
+     */
+    noModern?: boolean;
+    /**
+     * suppress Rosh Chodesh
+     */
+    noRoshChodesh?: boolean;
+    /**
+     * add Shabbat Mevarchim
+     */
+    shabbatMevarchim?: boolean;
+    /**
+     * suppress Special Shabbat
+     */
+    noSpecialShabbat?: boolean;
+    /**
+     * suppress regular holidays
+     */
+    noHolidays?: boolean;
+    /**
+     * include Days of the Omer
+     */
+    omer?: boolean;
+    /**
+     * include event announcing the molad
+     */
+    molad?: boolean;
+    /**
+     * use Ashkenazi transliterations for event titles (default Sephardi transliterations)
+     */
+    ashkenazi?: boolean;
+    /**
+     * translate event titles according to a locale
+     * Default value is `en`, also built-in are `he` and `ashkenazi`.
+     * Additional locales (such as `ru` or `fr`) are provided by the
+     * {@link https://github.com/hebcal/hebcal-locales @hebcal/locales} package
+     */
+    locale?: string;
+    /**
+     * print the Hebrew date for the entire date range
+     */
+    addHebrewDates?: boolean;
+    /**
+     * print the Hebrew date for dates with some events
+     */
+    addHebrewDatesForEvents?: boolean;
+    /**
+     * use bitmask from `flags` to filter events
+     */
+    mask?: number;
+    /**
+     * include Yom Kippur Katan (default `false`).
+     * יוֹם כִּפּוּר קָטָן is a minor day of atonement occurring monthly on the day preceeding each Rosh Chodesh.
+     * Yom Kippur Katan is omitted in Elul (on the day before Rosh Hashanah),
+     * Tishrei (Yom Kippur has just passed), Kislev (due to Chanukah)
+     * and Nisan (fasting not permitted during Nisan).
+     * When Rosh Chodesh occurs on Shabbat or Sunday, Yom Kippur Katan is observed on the preceding Thursday.
+     * See {@link https://en.wikipedia.org/wiki/Yom_Kippur_Katan#Practices Wikipedia Yom Kippur Katan practices}
+     */
+    yomKippurKatan?: boolean;
+    /**
+     * Whether to use 12-hour time (as opposed to 24-hour time).
+     * Possible values are `true` and `false`; the default is locale dependent.
+     */
+    hour12?: boolean;
+    /**
+     * map of options to enable daily study calendars
+     * such as `dafYomi`, `mishnaYomi`, `nachYomi` with value `true`. For `yerushalmi`
+     * the value should be a `number` for edition (`1` for Vilna, `2` for Schottenstein).
+     */
+    dailyLearning?: {
+        [x: string]: any;
+    };
+};
+
+/** Candle lighting before Shabbat or holiday */
+export declare class CandleLightingEvent extends TimedEvent {
+    constructor(date: HDate, mask: number, eventTime: Date, location: Location_2, linkedEvent?: Event_2, options?: CalOptions);
+    /** @return {string} */
+    getEmoji(): string;
+}
+
+/**
+ * Plug-ins for daily learning calendars such as Daf Yomi, Mishna Yomi, Nach Yomi, etc.
+ *
+ * Learning schedules are provided by the `@hebcal/learning` package.
+ */
+export declare class DailyLearning {
+    /**
+     * Register a new learning calendar.
+     * @param {string} name
+     * @param {Function} calendar
+     */
+    static addCalendar(name: string, calendar: Function): void;
+    /**
+     * Returns an event from daily calendar for a given date. Returns `null` if there
+     * is no learning from this calendar on this date.
+     * @param {string} name
+     * @param {HDate} hd
+     * @param {boolean} il
+     * @return {Event | null}
+     */
+    static lookup(name: string, hd: HDate, il: boolean): Event_2 | null;
+}
+
+/** Represents an Event with a title, date, and flags */
+declare class Event_2 {
+    readonly date: HDate;
+    readonly desc: string;
+    readonly mask: number;
+    emoji?: string;
+    memo?: string;
+    alarm?: Date;
+    /**
+     * Constructs Event
+     * @param {HDate} date Hebrew date event occurs
+     * @param {string} desc Description (not translated)
+     * @param {number} [mask=0] optional bitmask of holiday flags (see {@link flags})
+     * @param {Object} [attrs={}] optional additional attributes (e.g. `eventTimeStr`, `cholHaMoedDay`)
+     */
+    constructor(date: HDate, desc: string, mask?: number, attrs?: object);
+    /**
+     * Hebrew date of this event
+     * @return {HDate}
+     */
+    getDate(): HDate;
+    /**
+     * Untranslated description of this event
+     * @return {string}
+     */
+    getDesc(): string;
+    /**
+     * Bitmask of optional event flags. See {@link flags}
+     * @return {number}
+     */
+    getFlags(): number;
+    /**
+     * Returns (translated) description of this event
+     * @example
+     * const ev = new Event(new HDate(6, 'Sivan', 5749), 'Shavuot', flags.CHAG);
+     * ev.render('en'); // 'Shavuot'
+     * ev.render('he'); // 'שָׁבוּעוֹת'
+     * ev.render('ashkenazi'); // 'Shavuos'
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /**
+     * Returns a brief (translated) description of this event.
+     * For most events, this is the same as render(). For some events, it procudes
+     * a shorter text (e.g. without a time or added description).
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    renderBrief(locale?: string): string;
+    /**
+     * Optional holiday-specific Emoji or `null`.
+     * @return {string | null}
+     */
+    getEmoji(): string | null;
+    /**
+     * Returns a simplified (untranslated) description for this event. For example,
+     * the {@link HolidayEvent} class supports
+     * "Erev Pesach" => "Pesach", and "Sukkot III (CH''M)" => "Sukkot".
+     * For many holidays the basename and the event description are the same.
+     * @return {string}
+     */
+    basename(): string;
+    /**
+     * Returns a URL to hebcal.com or sefaria.org for more detail on the event.
+     * Returns `undefined` for events with no detail page.
+     * @return {string | undefined}
+     */
+    url(): string | undefined;
+    /**
+     * Is this event observed in Israel?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInIsrael(); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInIsrael(); // true
+     * @return {boolean}
+     */
+    observedInIsrael(): boolean;
+    /**
+     * Is this event observed in the Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedInDiaspora(); // true
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedInDiaspora(); // true
+     * @return {boolean}
+     */
+    observedInDiaspora(): boolean;
+    /**
+     * Is this event observed in Israel/Diaspora?
+     * @example
+     * const ev1 = new Event(new HDate(7, 'Sivan', 5749), 'Shavuot II', flags.CHAG | flags.CHUL_ONLY);
+     * ev1.observedIn(false); // true
+     * ev1.observedIn(true); // false
+     * const ev2 = new Event(new HDate(26, 'Kislev', 5749), 'Chanukah: 3 Candles', 0);
+     * ev2.observedIn(false); // true
+     * ev2.observedIn(true); // true
+     * @param {boolean} il
+     * @return {boolean}
+     */
+    observedIn(il: boolean): boolean;
+    /**
+     * Makes a clone of this Event object
+     * @return {Event}
+     */
+    clone(): Event_2;
+    /**
+     * Returns a list of event categories
+     * @return {string[]}
+     */
+    getCategories(): string[];
+}
+export { Event_2 as Event }
+
+/**
+ * Holiday flags for Event
+ * @readonly
+ * @enum {number}
+ */
+export declare const flags: {
+    /** Chag, yontiff, yom tov */
+    CHAG: number;
+    /** Light candles 18 minutes before sundown */
+    LIGHT_CANDLES: number;
+    /** End of holiday (end of Yom Tov)  */
+    YOM_TOV_ENDS: number;
+    /** Observed only in the Diaspora (chutz l'aretz)  */
+    CHUL_ONLY: number;
+    /** Observed only in Israel */
+    IL_ONLY: number;
+    /** Light candles in the evening at Tzeit time (3 small stars) */
+    LIGHT_CANDLES_TZEIS: number;
+    /** Candle-lighting for Chanukah */
+    CHANUKAH_CANDLES: number;
+    /** Rosh Chodesh, beginning of a new Hebrew month */
+    ROSH_CHODESH: number;
+    /** Minor fasts like Tzom Tammuz, Ta'anit Esther, ... */
+    MINOR_FAST: number;
+    /** Shabbat Shekalim, Zachor, ... */
+    SPECIAL_SHABBAT: number;
+    /** Weekly sedrot on Saturdays */
+    PARSHA_HASHAVUA: number;
+    /** Daily page of Talmud (Bavli) */
+    DAF_YOMI: number;
+    /** Days of the Omer */
+    OMER_COUNT: number;
+    /** Yom HaShoah, Yom HaAtzma'ut, ... */
+    MODERN_HOLIDAY: number;
+    /** Yom Kippur and Tish'a B'Av */
+    MAJOR_FAST: number;
+    /** On the Saturday before Rosh Chodesh */
+    SHABBAT_MEVARCHIM: number;
+    /** Molad */
+    MOLAD: number;
+    /** Yahrzeit or Hebrew Anniversary */
+    USER_EVENT: number;
+    /** Daily Hebrew date ("11th of Sivan, 5780") */
+    HEBREW_DATE: number;
+    /** A holiday that's not major, modern, rosh chodesh, or a fast day */
+    MINOR_HOLIDAY: number;
+    /** Evening before a major or minor holiday */
+    EREV: number;
+    /** Chol haMoed, intermediate days of Pesach or Sukkot */
+    CHOL_HAMOED: number;
+    /** Mishna Yomi */
+    MISHNA_YOMI: number;
+    /** Yom Kippur Katan, minor day of atonement on the day preceeding each Rosh Chodesh */
+    YOM_KIPPUR_KATAN: number;
+    /** Daily page of Jerusalem Talmud (Yerushalmi) */
+    YERUSHALMI_YOMI: number;
+    /** Nach Yomi */
+    NACH_YOMI: number;
+    /** Daily Learning */
+    DAILY_LEARNING: number;
+};
+
+export { gematriya }
+
+export { gematriyaStrToNum }
+
+export { GeoLocation }
+
+export { greg }
+
+/** Havdalah after Shabbat or holiday */
+export declare class HavdalahEvent extends TimedEvent {
+    private readonly havdalahMins?;
+    constructor(date: HDate, mask: number, eventTime: Date, location: Location_2, havdalahMins?: number, linkedEvent?: Event_2, options?: CalOptions);
+    /**
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /**
+     * Returns translation of "Havdalah" without the time.
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    renderBrief(locale?: string): string;
+    /** @return {string} */
+    getEmoji(): string;
+}
+
+export { HDate }
+
+/**
+ * HebrewCalendar is the main interface to the `@hebcal/core` library.
+ * This namespace is used to calculate holidays, rosh chodesh, candle lighting & havdalah times,
+ * Parashat HaShavua, Daf Yomi, days of the omer, and the molad.
+ * Event names can be rendered in several languges using the `locale` option.
+ */
+export declare class HebrewCalendar {
+    /**
+     * Calculates holidays and other Hebrew calendar events based on {@link CalOptions}.
+     *
+     * Each holiday is represented by an {@link Event} object which includes a date,
+     * a description, flags and optional attributes.
+     * If given no options, returns holidays for the Diaspora for the current Gregorian year.
+     *
+     * The date range returned by this function can be controlled by:
+     * * `options.year` - Gregorian (e.g. 1993) or Hebrew year (e.g. 5749)
+     * * `options.isHebrewYear` - to interpret `year` as Hebrew year
+     * * `options.numYears` - generate calendar for multiple years (default 1)
+     * * `options.month` - Gregorian or Hebrew month (to filter results to a single month)
+     *
+     * Alternatively, specify start and end days with `Date` or {@link HDate} instances:
+     * * `options.start` - use specific start date (requires `end` date)
+     * * `options.end` - use specific end date (requires `start` date)
+     *
+     * Unless `options.noHolidays == true`, default holidays include:
+     * * Major holidays - Rosh Hashana, Yom Kippur, Pesach, Sukkot, etc.
+     * * Minor holidays - Purim, Chanukah, Tu BiShvat, Lag BaOmer, etc.
+     * * Minor fasts - Ta'anit Esther, Tzom Gedaliah, etc. (unless `options.noMinorFast`)
+     * * Special Shabbatot - Shabbat Shekalim, Zachor, etc. (unless `options.noSpecialShabbat`)
+     * * Modern Holidays - Yom HaShoah, Yom HaAtzma'ut, etc. (unless `options.noModern`)
+     * * Rosh Chodesh (unless `options.noRoshChodesh`)
+     *
+     * Holiday and Torah reading schedules differ between Israel and the Disapora.
+     * Set `options.il=true` to use the Israeli schedule.
+     *
+     * Additional non-default event types can be specified:
+     * * Parashat HaShavua - weekly Torah Reading on Saturdays (`options.sedrot`)
+     * * Counting of the Omer (`options.omer`)
+     * * Shabbat Mevarchim HaChodesh on Saturday before Rosh Chodesh (`options.shabbatMevarchim`)
+     * * Molad announcement on Saturday before Rosh Chodesh (`options.molad`)
+     * * Yom Kippur Katan (`options.yomKippurKatan`)
+     *
+     * Daily Study of texts are supported by the
+     * {@link https://github.com/hebcal/hebcal-learning @hebcal/learning} package,
+     * for example:
+     * * Babylonian Talmud Daf Yomi (`options.dailyLearning.dafYomi`)
+     * * Jerusalem Talmud (Yerushalmi) Yomi (`options.dailyLearning.yerushalmi`)
+     * * Mishna Yomi (`options.dailyLearning.mishnaYomi`)
+     * * Nach Yomi (`options.dailyLearning.nachYomi`)
+     *
+     * Candle-lighting and Havdalah times are approximated using latitude and longitude
+     * specified by the {@link Location} class. The `Location` class contains a small
+     * database of cities with their associated geographic information and time-zone information.
+     * If you ever have any doubts about Hebcal's times, consult your local halachic authority.
+     * If you enter geographic coordinates above the arctic circle or antarctic circle,
+     * the times are guaranteed to be wrong.
+     *
+     * To add candle-lighting options, set `options.candlelighting=true` and set
+     * `options.location` to an instance of `Location`. By default, candle lighting
+     * time is 18 minutes before sundown (40 minutes for Jerusalem,
+     * 30 minutes for Haifa and Zikhron Ya'akov) and Havdalah is
+     * calculated according to Tzeit Hakochavim - Nightfall (the point when 3 small stars
+     * are observable in the night time sky with the naked eye). The default Havdalah
+     * option (Tzeit Hakochavim) is calculated when the sun is 8.5° below the horizon.
+     * These defaults can be changed using these options:
+     * * `options.candleLightingMins` - minutes before sundown to light candles
+     * * `options.havdalahMins` - minutes after sundown for Havdalah (typical values are 42, 50, or 72).
+     *    Havdalah times are suppressed when `options.havdalahMins=0`.
+     * * `options.havdalahDeg` - degrees for solar depression for Havdalah.
+     *    Default is 8.5 degrees for 3 small stars. Use 7.083 degrees for 3 medium-sized stars.
+     *    Havdalah times are suppressed when `options.havdalahDeg=0`.
+     *
+     * If both `options.candlelighting=true` and `options.location` is specified,
+     * Chanukah candle-lighting times and minor fast start/end times will also be generated.
+     * Chanukah candle-lighting is at Bein HaShmashos (13.5 minutes before
+     * the sun is 7.083° below the horizon in the evening)
+     * on weekdays, at regular candle-lighting time on Fridays, and at regular Havdalah time on
+     * Saturday night (see above).
+     *
+     * Minor fasts begin at Alot HaShachar (sun is 16.1° below the horizon in the morning) and
+     * end when 3 medium-sized stars are observable in the night sky (sun is 7.083° below the horizon
+     * in the evening).
+     *
+     * Two options also exist for generating an Event with the Hebrew date:
+     * * `options.addHebrewDates` - print the Hebrew date for the entire date range
+     * * `options.addHebrewDatesForEvents` - print the Hebrew date for dates with some events
+     *
+     * Lastly, translation and transliteration of event titles is controlled by
+     * `options.locale` and the {@link Locale} API.
+     * `@hebcal/core` supports three locales by default:
+     * * `en` - default, Sephardic transliterations (e.g. "Shabbat")
+     * * `ashkenazi` - Ashkenazi transliterations (e.g. "Shabbos")
+     * * `he` - Hebrew (e.g. "שַׁבָּת")
+     *
+     * Additional locales (such as `ru` or `fr`) are supported by the
+     * {@link https://github.com/hebcal/hebcal-locales @hebcal/locales} package
+     *
+     * @example
+     * import {HebrewCalendar, HDate, Location, Event} from '@hebcal/core';
+     * const options: CalOptions = {
+     *   year: 1981,
+     *   isHebrewYear: false,
+     *   candlelighting: true,
+     *   location: Location.lookup('San Francisco'),
+     *   sedrot: true,
+     *   omer: true,
+     * };
+     * const events = HebrewCalendar.calendar(options);
+     * for (const ev of events) {
+     *   const hd = ev.getDate();
+     *   const date = hd.greg();
+     *   console.log(date.toLocaleDateString(), ev.render('en'), hd.toString());
+     * }
+     * @param {CalOptions} [options={}]
+     * @return {Event[]}
+     */
+    static calendar(options?: CalOptions): Event_2[];
+    /**
+     * Calculates a birthday or anniversary (non-yahrzeit).
+     * `hyear` must be after original `gdate` of anniversary.
+     * Returns `undefined` when requested year preceeds or is same as original year.
+     *
+     * Hebcal uses the algorithm defined in "Calendrical Calculations"
+     * by Edward M. Reingold and Nachum Dershowitz.
+     *
+     * The birthday of someone born in Adar of an ordinary year or Adar II of
+     * a leap year is also always in the last month of the year, be that Adar
+     * or Adar II. The birthday in an ordinary year of someone born during the
+     * first 29 days of Adar I in a leap year is on the corresponding day of Adar;
+     * in a leap year, the birthday occurs in Adar I, as expected.
+     *
+     * Someone born on the thirtieth day of Marcheshvan, Kislev, or Adar I
+     * has his birthday postponed until the first of the following month in
+     * years where that day does not occur. [Calendrical Calculations p. 111]
+     * @example
+     * import {HebrewCalendar} from '@hebcal/core';
+     * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
+     * const hd = HebrewCalendar.getBirthdayOrAnniversary(5780, dt); // '1 Nisan 5780'
+     * console.log(hd.greg().toLocaleDateString('en-US')); // '3/26/2020'
+     * @param {number} hyear Hebrew year
+     * @param {Date|HDate} gdate Gregorian or Hebrew date of event
+     * @return {HDate | undefined} anniversary occurring in `hyear`
+     */
+    static getBirthdayOrAnniversary(hyear: number, gdate: Date | HDate): HDate | undefined;
+    /**
+     * Calculates yahrzeit.
+     * `hyear` must be after original `gdate` of death.
+     * Returns `undefined` when requested year preceeds or is same as original year.
+     *
+     * Hebcal uses the algorithm defined in "Calendrical Calculations"
+     * by Edward M. Reingold and Nachum Dershowitz.
+     *
+     * The customary anniversary date of a death is more complicated and depends
+     * also on the character of the year in which the first anniversary occurs.
+     * There are several cases:
+     *
+     * * If the date of death is Marcheshvan 30, the anniversary in general depends
+     *   on the first anniversary; if that first anniversary was not Marcheshvan 30,
+     *   use the day before Kislev 1.
+     * * If the date of death is Kislev 30, the anniversary in general again depends
+     *   on the first anniversary — if that was not Kislev 30, use the day before
+     *   Tevet 1.
+     * * If the date of death is Adar II, the anniversary is the same day in the
+     *   last month of the Hebrew year (Adar or Adar II).
+     * * If the date of death is Adar I 30, the anniversary in a Hebrew year that
+     *   is not a leap year (in which Adar only has 29 days) is the last day in
+     *   Shevat.
+     * * In all other cases, use the normal (that is, same month number) anniversary
+     *   of the date of death. [Calendrical Calculations p. 113]
+     * @example
+     * import {HebrewCalendar} from '@hebcal/core';
+     * const dt = new Date(2014, 2, 2); // '2014-03-02' == '30 Adar I 5774'
+     * const hd = HebrewCalendar.getYahrzeit(5780, dt); // '30 Sh\'vat 5780'
+     * console.log(hd.greg().toLocaleDateString('en-US')); // '2/25/2020'
+     * @param {number} hyear Hebrew year
+     * @param {Date|HDate} gdate Gregorian or Hebrew date of death
+     * @return {HDate | undefined} anniversary occurring in hyear
+     */
+    static getYahrzeit(hyear: number, gdate: Date | HDate): HDate | undefined;
+    /**
+     * Lower-level holidays interface, which returns a `Map` of `Event`s indexed by
+     * `HDate.toString()`. These events must filtered especially for `flags.IL_ONLY`
+     * or `flags.CHUL_ONLY` depending on Israel vs. Diaspora holiday scheme.
+     * @function
+     * @param {number} year Hebrew year
+     * @return {HolidayYearMap}
+     */
+    static getHolidaysForYear(year: number): HolidayYearMap;
+    /**
+     * Returns an array of holidays for the year
+     * @param {number} year Hebrew year
+     * @param {boolean} il use the Israeli schedule for holidays
+     * @return {HolidayEvent[]}
+     */
+    static getHolidaysForYearArray(year: number, il: boolean): HolidayEvent[];
+    /**
+     * Returns an array of Events on this date (or `undefined` if no events)
+     * @param {HDate|Date|number} date Hebrew Date, Gregorian date, or absolute R.D. day number
+     * @param {boolean} [il] use the Israeli schedule for holidays
+     * @return {HolidayEvent[] | undefined}
+     */
+    static getHolidaysOnDate(date: HDate | Date | number, il?: boolean): HolidayEvent[] | undefined;
+    /**
+     * Eruv Tavshilin
+     * @param {Date | HDate} date
+     * @param {boolean} il
+     * @return {boolean}
+     */
+    static eruvTavshilin(date: Date | HDate, il: boolean): boolean;
+    /**
+     * Helper function to format a 23-hour (00:00-23:59) time in US format ("8:13pm") or
+     * keep as "20:13" for any other locale/country. Uses {@link CalOptions} to determine
+     * locale.
+     * If `options.hour12` is `false`, locale is ignored and always returns 24-hour time.
+     * If `options.hour12` is `true`, locale is ignored and always returns 12-hour time.
+     * @param {string} timeStr - original time like "20:30"
+     * @param {string} suffix - "p" or "pm" or " P.M.". Add leading space if you want it
+     * @param {CalOptions} options
+     * @return {string}
+     */
+    static reformatTimeStr(timeStr: string, suffix: string, options: CalOptions): string;
+    /** @return {string} */
+    static version(): string;
+    /**
+     * Convenience function to create an instance of `Sedra` or reuse a previously
+     * created and cached instance.
+     * @function
+     * @param {number} hyear
+     * @param {boolean} il
+     * @return {Sedra}
+     */
+    static getSedra(hyear: number, il: boolean): Sedra;
+    /**
+     * Return a number containing information on what Hallel is said on that day.
+     *
+     * Whole Hallel is said on Chanukah, the first Yom Tov of Pesach, Shavuot, Sukkot,
+     * Yom Ha'atzmaut, and Yom Yerushalayim.
+     *
+     * Half Hallel is said on Rosh Chodesh (not Rosh Hashanah), and the last 6 days of Pesach.
+     *
+     * The number is one of the following values:
+     *
+     * 0 - No Hallel
+     * 1 - Half Hallel
+     * 2 - Whole Hallel
+     *
+     * @param {HDate} hdate
+     * @param {boolean} il
+     * @return {number}
+     */
+    static hallel(hdate: HDate, il: boolean): number;
+    /**
+     * Return details on what Tachanun (or Tzidchatcha on Shabbat) is said on `hdate`.
+     *
+     * Tachanun is not said on Rosh Chodesh, the month of Nisan, Lag Baomer,
+     * Rosh Chodesh Sivan until Isru Chag, Tisha B'av, 15 Av, Erev Rosh Hashanah,
+     * Rosh Hashanah, Erev Yom Kippur until after Simchat Torah, Chanukah,
+     * Tu B'shvat, Purim and Shushan Purim, and Purim and Shushan Purim Katan.
+     *
+     * In some congregations Tachanun is not said until from Rosh Chodesh Sivan
+     * until 14th Sivan, Sukkot until after Rosh Chodesh Cheshvan, Pesach Sheini,
+     * Yom Ha'atzmaut, and Yom Yerushalayim.
+     *
+     * Tachanun is not said at Mincha on days before it is not said at Shacharit.
+     *
+     * Tachanun is not said at Shacharit on Shabbat, but is at Mincha, usually.
+     * @param {HDate} hdate
+     * @param {boolean} il
+     * @return {TachanunResult}
+     */
+    static tachanun(hdate: HDate, il: boolean): TachanunResult;
+}
+
+/** Daily Hebrew date ("11th of Sivan, 5780") */
+export declare class HebrewDateEvent extends Event_2 {
+    /**
+     * @param {HDate} date
+     */
+    constructor(date: HDate);
+    /**
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @example
+     * import {HDate, HebrewDateEvent, months} from '@hebcal/core';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * const ev = new HebrewDateEvent(hd);
+     * console.log(ev.render('en')); // '15th of Cheshvan, 5769'
+     * console.log(ev.render('he')); // 'ט״ו חֶשְׁוָן תשס״ט'
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /**
+     * @private
+     * @param {string} locale
+     * @return {string}
+     */
+    private renderBriefHebrew;
+    /**
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @example
+     * import {HDate, HebrewDateEvent, months} from '@hebcal/core';
+     *
+     * const hd = new HDate(15, months.CHESHVAN, 5769);
+     * const ev = new HebrewDateEvent(hd);
+     * console.log(ev.renderBrief()); // '15th of Cheshvan'
+     * console.log(ev.renderBrief('he')); // 'ט״ו חֶשְׁוָן'
+     * @return {string}
+     */
+    renderBrief(locale?: string): string;
+}
+
+/**
+ * Transliterated names of holidays, used by `Event.getDesc()`
+ * @readonly
+ * @enum {string}
+ */
+export declare const holidayDesc: {
+    /** Asara B'Tevet */
+    ASARA_BTEVET: string;
+    /** Birkat Hachamah */
+    BIRKAT_HACHAMAH: string;
+    /** Chag HaBanot */
+    CHAG_HABANOT: string;
+    /** Chanukah: 8th Day */
+    CHANUKAH_8TH_DAY: string;
+    /** Erev Tish'a B'Av */
+    EREV_TISHA_BAV: string;
+    /** Leil Selichot */
+    LEIL_SELICHOT: string;
+    /** Purim Katan */
+    PURIM_KATAN: string;
+    /** Purim Meshulash */
+    PURIM_MESHULASH: string;
+    /** Shabbat Chazon */
+    SHABBAT_CHAZON: string;
+    /** Shabbat HaChodesh */
+    SHABBAT_HACHODESH: string;
+    /** Shabbat HaGadol */
+    SHABBAT_HAGADOL: string;
+    /** Shabbat Nachamu */
+    SHABBAT_NACHAMU: string;
+    /** Shabbat Parah */
+    SHABBAT_PARAH: string;
+    /** Shabbat Shekalim */
+    SHABBAT_SHEKALIM: string;
+    /** Shabbat Shirah */
+    SHABBAT_SHIRAH: string;
+    /** Shabbat Shuva */
+    SHABBAT_SHUVA: string;
+    /** Shabbat Zachor */
+    SHABBAT_ZACHOR: string;
+    /** Shushan Purim Katan */
+    SHUSHAN_PURIM_KATAN: string;
+    /** Ta'anit Bechorot */
+    TAANIT_BECHOROT: string;
+    /** Ta'anit Esther */
+    TAANIT_ESTHER: string;
+    /** Tish'a B'Av */
+    TISHA_BAV: string;
+    /** Tzom Gedaliah */
+    TZOM_GEDALIAH: string;
+    /** Tzom Tammuz */
+    TZOM_TAMMUZ: string;
+    /** Yom HaAtzma'ut */
+    YOM_HAATZMA_UT: string;
+    /** Yom HaShoah */
+    YOM_HASHOAH: string;
+    /** Yom HaZikaron */
+    YOM_HAZIKARON: string;
+    /** Ben-Gurion Day */
+    BEN_GURION_DAY: string;
+    /** Chanukah: 1 Candle */
+    CHANUKAH_1_CANDLE: string;
+    /** Erev Pesach */
+    EREV_PESACH: string;
+    /** Erev Purim */
+    EREV_PURIM: string;
+    /** Erev Rosh Hashana */
+    EREV_ROSH_HASHANA: string;
+    /** Erev Shavuot */
+    EREV_SHAVUOT: string;
+    /** Erev Sukkot */
+    EREV_SUKKOT: string;
+    /** Erev Yom Kippur */
+    EREV_YOM_KIPPUR: string;
+    /** Family Day */
+    FAMILY_DAY: string;
+    /** Hebrew Language Day */
+    HEBREW_LANGUAGE_DAY: string;
+    /** Herzl Day */
+    HERZL_DAY: string;
+    /** Jabotinsky Day */
+    JABOTINSKY_DAY: string;
+    /** Lag BaOmer */
+    LAG_BAOMER: string;
+    /** Pesach I */
+    PESACH_I: string;
+    /** Pesach II */
+    PESACH_II: string;
+    /** Pesach III (CH''M) */
+    PESACH_III_CHM: string;
+    /** Pesach II (CH''M) */
+    PESACH_II_CHM: string;
+    /** Pesach IV (CH''M) */
+    PESACH_IV_CHM: string;
+    /** Pesach Sheni */
+    PESACH_SHENI: string;
+    /** Pesach VII */
+    PESACH_VII: string;
+    /** Pesach VIII */
+    PESACH_VIII: string;
+    /** Pesach VI (CH''M) */
+    PESACH_VI_CHM: string;
+    /** Pesach V (CH''M) */
+    PESACH_V_CHM: string;
+    /** Purim */
+    PURIM: string;
+    /** Rosh Hashana II */
+    ROSH_HASHANA_II: string;
+    /** Rosh Hashana LaBehemot */
+    ROSH_HASHANA_LABEHEMOT: string;
+    /** Shavuot */
+    SHAVUOT: string;
+    /** Shavuot I */
+    SHAVUOT_I: string;
+    /** Shavuot II */
+    SHAVUOT_II: string;
+    /** Shmini Atzeret */
+    SHMINI_ATZERET: string;
+    /** Shushan Purim */
+    SHUSHAN_PURIM: string;
+    /** Sigd */
+    SIGD: string;
+    /** Simchat Torah */
+    SIMCHAT_TORAH: string;
+    /** Sukkot I */
+    SUKKOT_I: string;
+    /** Sukkot II */
+    SUKKOT_II: string;
+    /** Sukkot III (CH''M) */
+    SUKKOT_III_CHM: string;
+    /** Sukkot II (CH''M) */
+    SUKKOT_II_CHM: string;
+    /** Sukkot IV (CH''M) */
+    SUKKOT_IV_CHM: string;
+    /** Sukkot VII (Hoshana Raba) */
+    SUKKOT_VII_HOSHANA_RABA: string;
+    /** Sukkot VI (CH''M) */
+    SUKKOT_VI_CHM: string;
+    /** Sukkot V (CH''M) */
+    SUKKOT_V_CHM: string;
+    /** Tu B\'Av */
+    TU_BAV: string;
+    /** Tu BiShvat */
+    TU_BISHVAT: string;
+    /** Yitzhak Rabin Memorial Day */
+    YITZHAK_RABIN_MEMORIAL_DAY: string;
+    /** Yom HaAliyah */
+    YOM_HAALIYAH: string;
+    /** Yom HaAliyah School Observance */
+    YOM_HAALIYAH_SCHOOL_OBSERVANCE: string;
+    /** Yom Kippur */
+    YOM_KIPPUR: string;
+    /** Yom Yerushalayim */
+    YOM_YERUSHALAYIM: string;
+};
+
+/** Represents a built-in holiday like Pesach, Purim or Tu BiShvat */
+export declare class HolidayEvent extends Event_2 {
+    /** During Sukkot or Pesach */
+    cholHaMoedDay?: number;
+    chanukahDay?: number;
+    /**
+     * `true` if the fast day was postponed a day to avoid Shabbat.
+     * - Tish'a B'Av postponed from the 9th to the 10th
+     * - Tzom Tammuz postponed from the 17th to the 18th
+     */
+    observed?: boolean;
+    /** For a Fast day, this will be a "Fast begins" event */
+    startEvent?: TimedEvent;
+    /** For a Fast day, this will be a "Fast ends" event */
+    endEvent?: TimedEvent;
+    /** @return {string} */
+    basename(): string;
+    /** @return {string | undefined} */
+    url(): string | undefined;
+    /** @return {string} */
+    urlDateSuffix(): string;
+    /** @return {string} */
+    getEmoji(): string;
+    /** @return {string[]} */
+    getCategories(): string[];
+    /**
+     * Returns (translated) description of this event
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /**
+     * Returns a brief (translated) description of this event.
+     * For most events, this is the same as render(). For some events, it procudes
+     * a shorter text (e.g. without a time or added description).
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    renderBrief(locale?: string): string;
+    /**
+     * Makes a clone of this Event object
+     * @return {Event}
+     */
+    clone(): HolidayEvent;
+}
+
+declare type HolidayYearMap = Map<string, HolidayEvent[]>;
+
+export { Locale }
+
+/** Class representing Location */
+declare class Location_2 extends GeoLocation {
+    private readonly il;
+    private readonly cc?;
+    private readonly geoid?;
+    /**
+     * Initialize a Location instance
+     * @param {number} latitude - Latitude as a decimal, valid range -90 thru +90 (e.g. 41.85003)
+     * @param {number} longitude - Longitude as a decimal, valid range -180 thru +180 (e.g. -87.65005)
+     * @param {boolean} il - in Israel (true) or Diaspora (false)
+     * @param {string} tzid - Olson timezone ID, e.g. "America/Chicago"
+     * @param {string} [cityName] - optional descriptive city name
+     * @param {string} [countryCode] - ISO 3166 alpha-2 country code (e.g. "FR")
+     * @param {string|number} [geoid] - optional string or numeric geographic ID
+     * @param {number} [elevation] - in meters (default `0`)
+     */
+    constructor(latitude: number, longitude: number, il: boolean, tzid: string, cityName?: string, countryCode?: string, geoid?: string | number, elevation?: number);
+    /** @return {boolean} */
+    getIsrael(): boolean;
+    /** @return {string | null} */
+    getName(): string | null;
+    /**
+     * Returns the location name, up to the first comma
+     * @return {string | null}
+     */
+    getShortName(): string | null;
+    /** @return {string | undefined} */
+    getCountryCode(): string | undefined;
+    /** @return {string} */
+    getTzid(): string;
+    /**
+     * Gets a 24-hour time formatter (e.g. 07:41 or 20:03) for this location
+     * @return {Intl.DateTimeFormat}
+     */
+    getTimeFormatter(): Intl.DateTimeFormat;
+    /** @return {string | number | undefined} */
+    getGeoId(): string | number | undefined;
+    /**
+     * Creates a location object from one of 60 "classic" Hebcal city names.
+     * The following city names are supported:
+     * 'Ashdod', 'Atlanta', 'Austin', 'Baghdad', 'Beer Sheva',
+     * 'Berlin', 'Baltimore', 'Bogota', 'Boston', 'Budapest',
+     * 'Buenos Aires', 'Buffalo', 'Chicago', 'Cincinnati', 'Cleveland',
+     * 'Dallas', 'Denver', 'Detroit', 'Eilat', 'Gibraltar', 'Haifa',
+     * 'Hawaii', 'Helsinki', 'Houston', 'Jerusalem', 'Johannesburg',
+     * 'Kiev', 'La Paz', 'Livingston', 'Las Vegas', 'London', 'Los Angeles',
+     * 'Marseilles', 'Miami', 'Minneapolis', 'Melbourne', 'Mexico City',
+     * 'Montreal', 'Moscow', 'New York', 'Omaha', 'Ottawa', 'Panama City',
+     * 'Paris', 'Pawtucket', 'Petach Tikvah', 'Philadelphia', 'Phoenix',
+     * 'Pittsburgh', 'Providence', 'Portland', 'Saint Louis', 'Saint Petersburg',
+     * 'San Diego', 'San Francisco', 'Sao Paulo', 'Seattle', 'Sydney',
+     * 'Tel Aviv', 'Tiberias', 'Toronto', 'Vancouver', 'White Plains',
+     * 'Washington DC', 'Worcester'
+     * @param {string} name
+     * @return {Location|undefined}
+     */
+    static lookup(name: string): Location_2 | undefined;
+    /** @return {string} */
+    toString(): string;
+    /**
+     * Converts legacy Hebcal timezone to a standard Olson tzid.
+     * @param {number} tz integer, GMT offset in hours
+     * @param {string} dst 'none', 'eu', 'usa', or 'israel'
+     * @return {string | undefined}
+     */
+    static legacyTzToTzid(tz: number, dst: string): string | undefined;
+    /**
+     * Converts timezone info from Zip-Codes.com to a standard Olson tzid.
+     * @example
+     * Location.getUsaTzid('AZ', 7, 'Y') // 'America/Denver'
+     * @param {string} state two-letter all-caps US state abbreviation like 'CA'
+     * @param {number} tz positive number, 5=America/New_York, 8=America/Los_Angeles
+     * @param {string} dst single char 'Y' or 'N'
+     * @return {string}
+     */
+    static getUsaTzid(state: string, tz: number, dst: string): string;
+    /**
+     * Adds a location name for `Location.lookup()` only if the name isn't
+     * already being used. Returns `false` if the name is already taken
+     * and `true` if successfully added.
+     * @param {string} cityName
+     * @param {Location} location
+     * @return {boolean}
+     */
+    static addLocation(cityName: string, location: Location_2): boolean;
+}
+export { Location_2 as Location }
+
+/** Represents Mevarchim haChodesh, the announcement of the new month */
+export declare class MevarchimChodeshEvent extends Event_2 {
+    readonly monthName: string;
+    /**
+     * Constructs Mevarchim haChodesh event
+     * @param {HDate} date Hebrew date event occurs
+     * @param {string} monthName Hebrew month name (not translated)
+     * @param {string} [memo]
+     */
+    constructor(date: HDate, monthName: string, memo: string);
+    /** @return {string} */
+    basename(): string;
+    /**
+     * Returns (translated) description of this event
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /**
+     * Returns (translated) description of this event
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    renderBrief(locale?: string): string;
+}
+
+/**
+ * Represents a molad, the moment when the new moon is "born"
+ */
+export declare class Molad {
+    private readonly m;
+    /**
+     * Calculates the molad for a Hebrew month
+     * @param {number} year
+     * @param {number} month
+     */
+    constructor(year: number, month: number);
+    /**
+     * @return {number}
+     */
+    getYear(): number;
+    /**
+     * @return {number}
+     */
+    getMonth(): number;
+    /**
+     * @return {string}
+     */
+    getMonthName(): string;
+    /**
+     * @return {number} Day of Week (0=Sunday, 6=Saturday)
+     */
+    getDow(): number;
+    /**
+     * @return {number} hour of day (0-23)
+     */
+    getHour(): number;
+    /**
+     * @return {number} minutes past hour (0-59)
+     */
+    getMinutes(): number;
+    /**
+     * @return {number} parts of a minute (0-17)
+     */
+    getChalakim(): number;
+    /**
+     * @param {string} [locale] Optional locale name (defaults to active locale)
+     * @param {CalOptions} options
+     * @return {string}
+     */
+    render(locale?: string, options?: CalOptions): string;
+}
+
+/** Represents a Molad announcement on Shabbat Mevarchim */
+export declare class MoladEvent extends Event_2 {
+    readonly molad: Molad;
+    private readonly options;
+    /**
+     * @param {HDate} date Hebrew date event occurs
+     * @param {number} hyear molad year
+     * @param {number} hmonth molad month
+     * @param {CalOptions} options
+     */
+    constructor(date: HDate, hyear: number, hmonth: number, options: CalOptions);
+    /**
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+}
+
+export { months }
+
+export { NOAACalculator }
+
+declare type NumberOrString = number | string;
+
+/** Represents a day 1-49 of counting the Omer from Pesach to Shavuot */
+export declare class OmerEvent extends Event_2 {
+    private readonly weekNumber;
+    private readonly daysWithinWeeks;
+    readonly omer: number;
+    emoji?: string;
+    /**
+     * @param {HDate} date
+     * @param {number} omerDay
+     */
+    constructor(date: HDate, omerDay: number);
+    /**
+     * @param {string} lang
+     * @return {string}
+     */
+    sefira(lang?: string): string;
+    /**
+     * @todo use gettext()
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /**
+     * Returns translation of "Omer day 22" without ordinal numbers.
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    renderBrief(locale?: string): string;
+    /** @return {string} */
+    getEmoji(): string;
+    /** @return {number} */
+    getWeeks(): number;
+    /** @return {number} */
+    getDaysWithinWeeks(): number;
+    /**
+     * @param {string} locale
+     * @return {string}
+     */
+    getTodayIs(locale: string): string;
+    /** @return {string} */
+    url(): string;
+}
+
+/**
+ * Represents one of 54 weekly Torah portions, always on a Saturday
+ */
+export declare class ParshaEvent extends Event_2 {
+    readonly parsha: string[];
+    readonly il: boolean;
+    readonly num: number | number[];
+    /**
+     * @param {HDate} date
+     * @param {string[]} parsha - untranslated name of single or double parsha,
+     *   such as ['Bereshit'] or ['Achrei Mot', 'Kedoshim']
+     * @param {boolean} [il]
+     * @param {number|number[]} [num]
+     */
+    constructor(date: HDate, parsha: string[], il?: boolean, num?: number | number[]);
+    /**
+     * @param {string} [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale.
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /** @return {string} */
+    basename(): string;
+    /** @return {string | undefined} */
+    url(): string | undefined;
+    /** @return {string} */
+    urlDateSuffix(): string;
+}
+
+/**
+ * The 54 parshiyot of the Torah as transilterated strings
+ * parshiot[0] == 'Bereshit', parshiot[1] == 'Noach', parshiot[52] == "Ha'azinu".
+ * @readonly
+ * @type {string[]}
+ */
+export declare const parshiot: string[];
+
+/** Represents Rosh Chodesh, the beginning of a new month */
+export declare class RoshChodeshEvent extends HolidayEvent {
+    /**
+     * Constructs Rosh Chodesh event
+     * @param {HDate} date Hebrew date event occurs
+     * @param {string} monthName Hebrew month name (not translated)
+     */
+    constructor(date: HDate, monthName: string);
+    /**
+     * Returns (translated) description of this event
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /** @return {string} */
+    basename(): string;
+    /** @return {string} */
+    getEmoji(): string;
+}
+
+/** Represents Rosh Hashana, the Jewish New Year */
+export declare class RoshHashanaEvent extends HolidayEvent {
+    private readonly hyear;
+    /**
+     * @private
+     * @param {HDate} date Hebrew date event occurs
+     * @param {number} hyear Hebrew year
+     * @param {number} mask optional holiday flags
+     */
+    constructor(date: HDate, hyear: number, mask: number);
+    /**
+     * Returns (translated) description of this event
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /** @return {string} */
+    getEmoji(): string;
+}
+
+/**
+ * Represents Parashah HaShavua for an entire Hebrew year
+ */
+export declare class Sedra {
+    private readonly year;
+    private readonly il;
+    private readonly firstSaturday;
+    private readonly theSedraArray;
+    /**
+     * Caculates the Parashah HaShavua for an entire Hebrew year
+     * @param {number} hyear - Hebrew year (e.g. 5749)
+     * @param {boolean} il - Use Israel sedra schedule (false for Diaspora)
+     */
+    constructor(hyear: number, il: boolean);
+    /**
+     * Returns the parsha (or parshiyot) read on Hebrew date
+     * @param {HDate|number} hd Hebrew date or R.D. days
+     * @return {string[]}
+     */
+    get(hd: HDate | number): string[];
+    /**
+     * Looks up parsha for the date, then returns a translated or transliterated string
+     * @param {HDate|number} hd Hebrew date or R.D. days
+     * @param {string} [locale] Optional locale name (i.e: `'he'`, `'fr'`). Defaults to active locale
+     * @return {string}
+     */
+    getString(hd: HDate | number, locale?: string): string;
+    /**
+     * Checks to see if this day would be a regular parasha HaShavua
+     * Torah reading or special holiday reading
+     * @param {HDate|number} hd Hebrew date or R.D. days
+     * @return {boolean}
+     */
+    isParsha(hd: HDate | number): boolean;
+    /**
+     * Returns the date that a parsha occurs
+     * or `null` if the parsha doesn't occur this year
+     * @param {number|string|string[]} parsha
+     * @return {HDate|null}
+     */
+    find(parsha: number | string | string[]): HDate | null;
+    /**
+     * Returns the underlying annual sedra schedule.
+     * Used by `@hebcal/triennial`
+     * @return {NumberOrString[]}
+     */
+    getSedraArray(): NumberOrString[];
+    /**
+     * R.D. date of the first Saturday on or after Rosh Hashana
+     * @return {number}
+     */
+    getFirstSaturday(): number;
+    /** @return {number} */
+    getYear(): number;
+    /**
+     * Returns an object describing the parsha on the first Saturday on or after `hd`
+     * @param {HDate|number} hd Hebrew date or R.D. days
+     * @return {SedraResult}
+     */
+    lookup(hd: HDate | number): SedraResult;
+}
+
+/** The result from `Sedra.lookup()` */
+export declare type SedraResult = {
+    /**
+     * Name of the parsha (or parshiyot) read on
+     * Hebrew date, e.g. `['Noach']` or `['Matot', 'Masei']`
+     */
+    parsha: string[];
+    /**
+     * True if this is a regular parasha HaShavua
+     * Torah reading, false if it's a special holiday reading
+     */
+    chag: boolean;
+    /**
+     * The parsha number (or numbers) using 1-indexing.
+     * A `number` for a regular (single) parsha, and a `number[]`
+     * for a doubled parsha.
+     * For Parashat *Bereshit*, `num` would be equal to `1`, and for
+     * *Matot-Masei* it would be `[42, 43]`
+     */
+    num?: number | number[];
+};
+
+/**
+ * Is *tachanun* said today?
+ */
+export declare type TachanunResult = {
+    /** Tachanun is said at Shacharit */
+    shacharit: boolean;
+    /** Tachanun is said at Mincha */
+    mincha: boolean;
+    /** All congregations say Tachanun on the day */
+    allCongs: boolean;
+};
+
+/** An event that has an `eventTime` and `eventTimeStr` */
+export declare class TimedEvent extends Event_2 {
+    readonly eventTime: Date;
+    readonly location: Location_2;
+    readonly eventTimeStr: string;
+    readonly fmtTime: string;
+    readonly linkedEvent?: Event_2;
+    /**
+     * @param {string} desc Description (not translated)
+     */
+    constructor(date: HDate, desc: string, mask: number, eventTime: Date, location: Location_2, linkedEvent?: Event_2, options?: CalOptions);
+    /**
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    render(locale?: string): string;
+    /**
+     * Returns translation of "Candle lighting" without the time.
+     * @param {string} [locale] Optional locale name (defaults to active locale).
+     * @return {string}
+     */
+    renderBrief(locale?: string): string;
+    /** @return {string[]} */
+    getCategories(): string[];
+}
+
+/** DO NOT EDIT THIS AUTO-GENERATED FILE! */
+export declare const version = "5.4.6";
+
+/**
+ * Calculate halachic times (zmanim / זְמַנִּים) for a given day and location.
+ * Calculations are available for tzeit / tzais (nightfall),
+ * shkiah (sunset) and more.
+ *
+ * Zmanim are estimated using an algorithm published by the US National Oceanic
+ * and Atmospheric Administration. The NOAA solar calculator is based on equations
+ * from _Astronomical Algorithms_ by Jean Meeus.
+ *
+ * The sunrise and sunset results are theoretically accurate to within a minute for
+ * locations between +/- 72° latitude, and within 10 minutes outside of those latitudes.
+ * However, due to variations in atmospheric composition, temperature, pressure and
+ * conditions, observed values may vary from calculations.
+ * https://gml.noaa.gov/grad/solcalc/calcdetails.html
+ *
+ * @example
+ * const {GeoLocation, Zmanim} = require('@hebcal/core');
+ * const latitude = 41.822232;
+ * const longitude = -71.448292;
+ * const tzid = 'America/New_York';
+ * const friday = new Date(2023, 8, 8);
+ * const gloc = new GeoLocation(null, latitude, longitude, 0, tzid);
+ * const zmanim = new Zmanim(gloc, friday, false);
+ * const candleLighting = zmanim.sunsetOffset(-18, true);
+ * const timeStr = Zmanim.formatISOWithTimeZone(tzid, candleLighting);
+ */
+export declare class Zmanim {
+    private readonly date;
+    private readonly gloc;
+    private readonly noaa;
+    private useElevation;
+    /**
+     * Initialize a Zmanim instance.
+     * @param {GeoLocation} gloc GeoLocation including latitude, longitude, and timezone
+     * @param {Date|HDate} date Regular or Hebrew Date. If `date` is a regular `Date`,
+     *    hours, minutes, seconds and milliseconds are ignored.
+     * @param {boolean} useElevation use elevation for calculations (default `false`).
+     *    If `true`, use elevation to affect the calculation of all sunrise/sunset based
+     *    zmanim. Note: there are some zmanim such as degree-based zmanim that are driven
+     *    by the amount of light in the sky and are not impacted by elevation.
+     *    These zmanim intentionally do not support elevation adjustment.
+     */
+    constructor(gloc: GeoLocation, date: Date | HDate, useElevation: boolean);
+    /**
+     * Returns `true` if elevation adjustment is enabled
+     * for zmanim support elevation adjustment
+     * @return {boolean}
+     */
+    getUseElevation(): boolean;
+    /**
+     * Enables or disables elevation adjustment for zmanim support elevation adjustment
+     * @param {boolean} useElevation
+     */
+    setUseElevation(useElevation: boolean): void;
+    /**
+     * Convenience function to get the time when sun is above or below the horizon
+     * for a certain angle (in degrees).
+     * This function does not support elevation adjustment.
+     * @param {number} angle
+     * @param {boolean} rising
+     * @return {Date}
+     */
+    timeAtAngle(angle: number, rising: boolean): Date;
+    /**
+     * Upper edge of the Sun appears over the eastern horizon in the morning (0.833° above horizon)
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    sunrise(): Date;
+    /**
+     * Upper edge of the Sun appears over the eastern horizon in the morning (0.833° above horizon).
+     * This function does not support elevation adjustment.
+     * @return {Date}
+     */
+    seaLevelSunrise(): Date;
+    /**
+     * When the upper edge of the Sun disappears below the horizon (0.833° below horizon).
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    sunset(): Date;
+    /**
+     * When the upper edge of the Sun disappears below the horizon (0.833° below horizon).
+     * This function does not support elevation adjustment.
+     * @return {Date}
+     */
+    seaLevelSunset(): Date;
+    /**
+     * Civil dawn; Sun is 6° below the horizon in the morning.
+     * Because degree-based functions estimate the amount of light in the sky,
+     * the result is not impacted by elevation.
+     * @return {Date}
+     */
+    dawn(): Date;
+    /**
+     * Civil dusk; Sun is 6° below the horizon in the evening.
+     * Because degree-based functions estimate the amount of light in the sky,
+     * the result is not impacted by elevation.
+     * @return {Date}
+     */
+    dusk(): Date;
+    /**
+     * Returns sunset for the previous day.
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    gregEve(): Date;
+    /**
+     * @private
+     * @return {number}
+     */
+    nightHour(): number;
+    /**
+     * Midday – Chatzot; Sunrise plus 6 halachic hours
+     * @return {Date}
+     */
+    chatzot(): Date;
+    /**
+     * Midnight – Chatzot; Sunset plus 6 halachic hours.
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    chatzotNight(): Date;
+    /**
+     * Dawn – Alot haShachar; Sun is 16.1° below the horizon in the morning.
+     * Because degree-based functions estimate the amount of light in the sky,
+     * the result is not impacted by elevation.
+     * @return {Date}
+     */
+    alotHaShachar(): Date;
+    /**
+     * Earliest talis & tefillin – Misheyakir; Sun is 11.5° below the horizon in the morning.
+     * Because degree-based functions estimate the amount of light in the sky,
+     * the result is not impacted by elevation.
+     * @return {Date}
+     */
+    misheyakir(): Date;
+    /**
+     * Earliest talis & tefillin – Misheyakir Machmir; Sun is 10.2° below the horizon in the morning.
+     * Because degree-based functions estimate the amount of light in the sky,
+     * the result is not impacted by elevation.
+     * @return {Date}
+     */
+    misheyakirMachmir(): Date;
+    /**
+     * Utility method for using elevation-aware sunrise/sunset
+     * @private
+     * @param {number} hours
+     * @return {Date}
+     */
+    getShaahZmanisBasedZman(hours: number): Date;
+    /**
+     * Latest Shema (Gra); Sunrise plus 3 halachic hours, according to the Gra.
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    sofZmanShma(): Date;
+    /**
+     * Latest Shacharit (Gra); Sunrise plus 4 halachic hours, according to the Gra.
+     *
+     * This method returns the latest *zman tfila* (time to recite shema in the morning)
+     * that is 4 *shaos zmaniyos* (solar hours) after sunrise or sea level sunrise
+     * (depending on the `useElevation` setting), according
+     * to the [GRA](https://en.wikipedia.org/wiki/Vilna_Gaon).
+     *
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    sofZmanTfilla(): Date;
+    /**
+     * Returns an array with alot (Date) and ms in hour (number)
+     * @private
+     */
+    getTemporalHour72(forceSeaLevel: boolean): [Date, number];
+    /**
+     * Returns an array with alot (Date) and ms in hour (number)
+     * @private
+     */
+    getTemporalHourByDeg(angle: number): [Date, number];
+    /**
+     * Latest Shema (MGA); Sunrise plus 3 halachic hours, according to Magen Avraham.
+     * Based on the opinion of the MGA that the day is calculated from
+     * dawn being fixed 72 minutes before sea-level sunrise, and nightfall is fixed
+     * 72 minutes after sea-level sunset.
+     * @return {Date}
+     */
+    sofZmanShmaMGA(): Date;
+    /**
+     * Latest Shema (MGA); Sunrise plus 3 halachic hours, according to Magen Avraham.
+     * Based on the opinion of the MGA that the day is calculated from
+     * dawn to nightfall with both being 16.1° below the horizon.
+     * @return {Date}
+     */
+    sofZmanShmaMGA16Point1(): Date;
+    /**
+     * Latest Shema (MGA); Sunrise plus 3 halachic hours, according to Magen Avraham.
+     * Based on the opinion of the MGA that the day is calculated from
+     * dawn to nightfall with both being 19.8° below the horizon.
+     *
+     * This calculation is based on the position of the sun 90 minutes after sunset in Jerusalem
+     * around the equinox / equilux which calculates to 19.8° below geometric zenith.
+     * https://kosherjava.com/2022/01/12/equinox-vs-equilux-zmanim-calculations/
+     * @return {Date}
+     */
+    sofZmanShmaMGA19Point8(): Date;
+    /**
+     * Latest Shacharit (MGA); Sunrise plus 4 halachic hours, according to Magen Avraham
+     * @return {Date}
+     */
+    sofZmanTfillaMGA(): Date;
+    /**
+     * Latest Shacharit (MGA); Sunrise plus 4 halachic hours, according to Magen Avraham.
+     * Based on the opinion of the MGA that the day is calculated from
+     * dawn to nightfall with both being 16.1° below the horizon.
+     * @return {Date}
+     */
+    sofZmanTfillaMGA16Point1(): Date;
+    /**
+     * Latest Shacharit (MGA); Sunrise plus 4 halachic hours, according to Magen Avraham.
+     * Based on the opinion of the MGA that the day is calculated from
+     * dawn to nightfall with both being 19.8° below the horizon.
+     *
+     * This calculation is based on the position of the sun 90 minutes after sunset in Jerusalem
+     * around the equinox / equilux which calculates to 19.8° below geometric zenith.
+     * https://kosherjava.com/2022/01/12/equinox-vs-equilux-zmanim-calculations/
+     * @return {Date}
+     */
+    sofZmanTfillaMGA19Point8(): Date;
+    /**
+     * Earliest Mincha – Mincha Gedola (GRA); Sunrise plus 6.5 halachic hours.
+     * If elevation is enabled, this function will include elevation in the calculation.
+     *
+     * This method returns the latest mincha gedola, the earliest time one can pray mincha
+     * that is 6.5 shaos zmaniyos (solar hours) after sunrise or sea level sunrise
+     * (depending on the `useElevation` setting), according
+     * to the [GRA](https://en.wikipedia.org/wiki/Vilna_Gaon).
+     *
+     * The Ramba"m is of the opinion that it is better to delay *mincha* until
+     * *mincha ketana* while the Ra"sh, Tur, GRA and others are of the
+     * opinion that *mincha* can be prayed *lechatchila* starting at *mincha gedola*.
+     * @return {Date}
+     */
+    minchaGedola(): Date;
+    /**
+     * Earliest Mincha – Mincha Gedola (MGA); Sunrise plus 6.5 halachic hours.
+     * If elevation is enabled, this function will include elevation in the calculation.
+     *
+     * This method returns the time of *mincha gedola* according to the Magen Avraham
+     * with the day starting 72 minutes before sunrise and ending 72 minutes after sunset.
+     * This is the earliest time to pray *mincha*.
+     * @return {Date}
+     */
+    minchaGedolaMGA(): Date;
+    /**
+     * Preferable earliest time to recite Minchah – Mincha Ketana; Sunrise plus 9.5 halachic hours.
+     * If elevation is enabled, this function will include elevation in the calculation.
+     *
+     * This method returns *mincha ketana*, the preferred earliest time to pray *mincha* in the
+     * opinion of the [Rambam](https://en.wikipedia.org/wiki/Maimonides) and others,
+     * that is 9.5 *shaos zmaniyos* (solar hours) after sunrise or sea level sunrise
+     * (depending on the `useElevation` setting), according
+     * to the [GRA](https://en.wikipedia.org/wiki/Vilna_Gaon).
+     * @return {Date}
+     */
+    minchaKetana(): Date;
+    /**
+     * This method returns the time of *mincha ketana* according to the Magen Avraham
+     * with the day starting 72 minutes before sunrise and ending 72 minutes after sunset.
+     * This is the preferred earliest time to pray *mincha* according to the opinion of
+     * the [Rambam](https://en.wikipedia.org/wiki/Maimonides) and others.
+     *
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    minchaKetanaMGA(): Date;
+    /**
+     * Plag haMincha; Sunrise plus 10.75 halachic hours.
+     * If elevation is enabled, this function will include elevation in the calculation.
+     * @return {Date}
+     */
+    plagHaMincha(): Date;
+    /**
+     * @param {number} [angle=8.5] optional time for solar depression.
+     *   Default is 8.5 degrees for 3 small stars, use 7.083 degrees for 3 medium-sized stars.
+     * Because degree-based functions estimate the amount of light in the sky,
+     * the result is not impacted by elevation.
+     * @return {Date}
+     */
+    tzeit(angle?: number): Date;
+    /**
+     * Alias for sunrise
+     * @return {Date}
+     */
+    neitzHaChama(): Date;
+    /**
+     * Alias for sunset
+     * @return {Date}
+     */
+    shkiah(): Date;
+    /**
+     * Rabbeinu Tam holds that bein hashmashos is a specific time
+     * between sunset and tzeis hakochavim.
+     * One opinion on how to calculate this time is that
+     * it is 13.5 minutes before tzies 7.083.
+     * Because degree-based functions estimate the amount of light in the sky,
+     * the result is not impacted by elevation.
+     * @return {Date}
+     */
+    beinHaShmashos(): Date;
+    /**
+     * Uses timeFormat to return a date like '20:34'
+     * @param {Date} dt
+     * @param {Intl.DateTimeFormat} timeFormat
+     * @return {string}
+     */
+    static formatTime(dt: Date, timeFormat: Intl.DateTimeFormat): string;
+    /**
+     * Discards seconds, rounding to nearest minute.
+     * @param {Date} dt
+     * @return {Date}
+     */
+    static roundTime(dt: Date): Date;
+    /**
+     * Get offset string (like "+05:00" or "-08:00") from tzid (like "Europe/Moscow")
+     * @param {string} tzid
+     * @param {Date} date
+     * @return {string}
+     */
+    static timeZoneOffset(tzid: string, date: Date): string;
+    /**
+     * Returns a string like "2022-04-01T13:06:00-11:00"
+     * @param {string} tzid
+     * @param {Date} date
+     * @return {string}
+     */
+    static formatISOWithTimeZone(tzid: string, date: Date): string;
+    /**
+     * Returns sunrise + `offset` minutes (either positive or negative).
+     * If elevation is enabled, this function will include elevation in the calculation
+     *  unless `forceSeaLevel` is `true`.
+     * @param {number} offset minutes
+     * @param {boolean} roundMinute round time to nearest minute (default true)
+     * @param {boolean} forceSeaLevel use sea-level sunrise (default false)
+     * @return {Date}
+     */
+    sunriseOffset(offset: number, roundMinute?: boolean, forceSeaLevel?: boolean): Date;
+    /**
+     * Returns sunset + `offset` minutes (either positive or negative).
+     * If elevation is enabled, this function will include elevation in the calculation
+     *  unless `forceSeaLevel` is `true`.
+     * @param {number} offset minutes
+     * @param {boolean} roundMinute round time to nearest minute (default true)
+     * @param {boolean} forceSeaLevel use sea-level sunset (default false)
+     * @return {Date}
+     */
+    sunsetOffset(offset: number, roundMinute?: boolean, forceSeaLevel?: boolean): Date;
+}
+
+export { }