export declare namespace EnglishDateTime {
    const LangMarker = "Eng";
    const CheckBothBeforeAfter = false;
    const TillRegex: string;
    const RangeConnectorRegex: string;
    const LastNegPrefix = "(?<!(w(ill|ould|on\\s*'\\s*t)|m(ay|ight|ust)|sh(all|ould(n\\s*'\\s*t)?)|c(an(\\s*'\\s*t|not)?|ould(n\\s*'\\s*t)?))(\\s+not)?\\s+)";
    const RelativeRegex: string;
    const StrictRelativeRegex: string;
    const UpcomingPrefixRegex = "((this\\s+)?((up)?coming))";
    const NextPrefixRegex: string;
    const AfterNextSuffixRegex = "\\b(after\\s+(the\\s+)?next)\\b";
    const PastPrefixRegex = "((this\\s+)?past)\\b";
    const PreviousPrefixRegex: string;
    const ThisPrefixRegex = "(this|current)\\b";
    const RangePrefixRegex = "(from|between)";
    const CenturySuffixRegex = "(^century)\\b";
    const ReferencePrefixRegex = "(that|same)\\b";
    const FutureSuffixRegex = "\\b((in\\s+the\\s+)?future|hence)\\b";
    const PastSuffixRegex = "\\b((in\\s+the\\s+)past)\\b";
    const DayRegex = "(the\\s*)?(?<!(\\d:|\\$)\\s*|\\d)(?<day>(?:3[0-1]|[1-2]\\d|0?[1-9])(?:th|nd|rd|st)?)(?=\\b|t)";
    const ImplicitDayRegex = "(the\\s*)?(?<day>(?:3[0-1]|[0-2]?\\d)(?:th|nd|rd|st))\\b";
    const MonthNumRegex = "(?<month>1[0-2]|(0)?[1-9])\\b";
    const WrittenOneToNineRegex = "(?:one|two|three|four|five|six|seven|eight|nine)";
    const WrittenElevenToNineteenRegex = "(?:eleven|twelve|(?:thir|four|fif|six|seven|eigh|nine)teen)";
    const WrittenTensRegex = "(?:ten|twenty|thirty|fou?rty|fifty|sixty|seventy|eighty|ninety)";
    const WrittenNumRegex: string;
    const WrittenOneToNineOrdinalRegex = "(?:first|second|third|fourth|fifth|sixth|seventh|eighth|nine?th)";
    const WrittenTensOrdinalRegex = "(?:tenth|eleventh|twelfth|thirteenth|fourteenth|fifteenth|sixteenth|seventeenth|eighteenth|nineteenth|twentieth|thirtieth|fortieth|fiftieth|sixtieth|seventieth|eightieth|ninetieth)";
    const WrittenOrdinalRegex: string;
    const WrittenOrdinalDayRegex: string;
    const WrittenCenturyFullYearRegex: string;
    const WrittenCenturyOrdinalYearRegex = "(?:twenty(\\s+(one|two))?|ten|eleven|twelve|thirteen|fifteen|eighteen|(?:four|six|seven|nine)(teen)?|one|two|three|five|eight)";
    const CenturyRegex: string;
    const LastTwoYearNumRegex: string;
    const FullTextYearRegex: string;
    const OclockRegex = "(?<oclock>o\\s*((\u2019|\u2018|')\\s*)?clock|sharp)";
    const SpecialDescRegex = "((?<ipm>)p\\b)";
    const TasksModeSpecialDescRegex = "([0-9]+((?<ipm>)p\\b))";
    const AmDescRegex: string;
    const PmDescRegex: string;
    const AmPmDescRegex: string;
    const DescRegex: string;
    const OfPrepositionRegex = "(\\bof\\b)";
    const TwoDigitYearRegex: string;
    const YearRegex: string;
    const WeekDayRegex = "\\b(?<weekday>(?:sun|mon|tues?|thurs?|fri)(day)?|thu|wedn(esday)?|weds?|sat(urday)?)s?\\b";
    const SingleWeekDayRegex = "\\b(?<weekday>(?<!(easter|palm)\\s+)sunday|(?<!easter\\s+)saturday|(?<!(easter|cyber)\\s+)monday|mon|(?<!black\\s+)friday|fri|(?:tues?|thurs?)(day)?|thu|wedn(esday)?|weds?|((?<=on\\s+)(sat|sun)))\\b";
    const RelativeMonthRegex: string;
    const MonthRegexNoWordBoundary = "(?<month>apr(il)?|aug(ust)?|dec(ember)?|feb(ruary)?|jan(uary)?|july?|june?|mar(ch)?|may|nov(ember)?|oct(ober)?|sept(ember)?|sep)(?!\\p{L})";
    const MonthRegex: string;
    const WrittenMonthRegex: string;
    const MonthSuffixRegex: string;
    const DateUnitRegex = "(?<unit>(decade|year|(?<uoy>month|week|fortnight)|(?<business>(business\\s+|week\\s*))?(?<uoy>day)|fortnight|weekend)(?<plural>s)?|(?<=(^|\\s)\\d{1,4})[ymwd])\\b";
    const DateTokenPrefix = "on ";
    const TimeTokenPrefix = "at ";
    const TokenBeforeDate = "on ";
    const TokenBeforeTime = "at ";
    const HalfTokenRegex = "^(half)";
    const QuarterTokenRegex = "^((a\\s+)?quarter)";
    const ThreeQuarterTokenRegex = "^(three\\s+quarters?)";
    const ToTokenRegex = "\\b(to)$";
    const FromRegex = "\\b(from(\\s+the)?)$";
    const BetweenTokenRegex = "\\b(between(\\s+the)?)$";
    const SimpleCasesRegex: string;
    const MonthFrontSimpleCasesRegex: string;
    const MonthFrontBetweenRegex: string;
    const BetweenRegex: string;
    const MonthWithYear: string;
    const SpecialYearPrefixes = "(calendar|(?<special>fiscal|school))";
    const OneWordPeriodRegex: string;
    const MonthNumWithYear: string;
    const WeekOfMonthRegex: string;
    const WeekOfYearRegex: string;
    const OfYearRegex: string;
    const FirstLastRegex = "\\b(the\\s+)?((?<first>first)|(?<last>last))\\b";
    const FollowedDateUnit: string;
    const NumberCombinedWithDateUnit: string;
    const QuarterTermRegex = "\\b(((?<cardinal>first|1st|second|2nd|third|3rd|fourth|4th)[ -]+quarter)|(q(?<number>[1-4])))\\b";
    const RelativeQuarterTermRegex: string;
    const QuarterRegex: string;
    const QuarterRegexYearFront: string;
    const HalfYearTermRegex = "(?<cardinal>first|1st|second|2nd)\\s+half";
    const HalfYearFrontRegex = "(?<year>((1[5-9]|20)\\d{2})|2100)(\\s*-\\s*|\\s+(the\\s+)?)?h(?<number>[1-2])";
    const HalfYearBackRegex: string;
    const HalfYearRelativeRegex: string;
    const AllHalfYearRegex: string;
    const EarlyPrefixRegex = "\\b(?<EarlyPrefix>early|beginning of|start of|(?<RelEarly>earlier(\\s+in)?))\\b";
    const MidPrefixRegex = "\\b(?<MidPrefix>mid-?|middle of)\\b";
    const LaterPrefixRegex = "\\b(?<LatePrefix>late|end of|(?<RelLate>later(\\s+in)?))\\b";
    const PrefixPeriodRegex: string;
    const PrefixDayRegex = "\\b((?<EarlyPrefix>earl(y|ier))|(?<MidPrefix>mid(dle)?)|(?<LatePrefix>later?))(\\s+in)?(\\s+the\\s+day)?$";
    const SeasonDescRegex = "(?<seas>spring|summer|fall|autumn|winter)";
    const SeasonRegex: string;
    const WhichWeekRegex: string;
    const WeekOfRegex = "(the\\s+)?((week)(\\s+(of|(commencing|starting|beginning)(\\s+on)?))|w/c)(\\s+the)?";
    const MonthOfRegex = "(month)(\\s*)(of)";
    const DateYearRegex: string;
    const YearSuffix: string;
    const OnRegex: string;
    const RelaxedOnRegex = "(?<=\\b(on|at|in)\\s+)((?<day>(3[0-1]|[0-2]?\\d)(?:th|nd|rd|st))s?)\\b";
    const PrefixWeekDayRegex = "(\\s*((,?\\s*on)|[-\u2014\u2013]))";
    const ThisRegex: string;
    const LastDateRegex: string;
    const NextDateRegex: string;
    const SpecialDayRegex: string;
    const SpecialDayWithNumRegex: string;
    const RelativeDayRegex: string;
    const SetWeekDayRegex = "\\b(?<prefix>on\\s+)?(?<weekday>morning|afternoon|evening|night|(sun|mon|tues|wednes|thurs|fri|satur)day)s\\b";
    const WeekDayOfMonthRegex: string;
    const RelativeWeekDayRegex: string;
    const SpecialDate: string;
    const DatePreposition = "\\b(on|in)";
    const DateExtractorYearTermRegex: string;
    const DayPrefix: string;
    const DateExtractor1: string;
    const DateExtractor3: string;
    const DateExtractor4: string;
    const DateExtractor5: string;
    const DateExtractor6: string;
    const DateExtractor7L: string;
    const DateExtractor7S: string;
    const DateExtractor8: string;
    const DateExtractor9L: string;
    const DateExtractor9S: string;
    const DateExtractorNoSep = "\\b((?<![$])(?<year>((1\\d|20)\\d{2})|2100)(\\s+(?<month>1[0-2]|(0)?[1-9])\\s+(?<day>(?:3[0-1]|[1-2]\\d|0?[1-9]))|(?<month>1[0-2]|(0)?[1-9])(?<day>(?:3[0-1]|[1-2]\\d|0?[1-9])))\\b)";
    const DateExtractorA: string;
    const OfMonth: string;
    const MonthEnd: string;
    const WeekDayEnd: string;
    const WeekDayStart: string;
    const RangeUnitRegex = "\\b(?<unit>years?|months?|weeks?|fortnights?)\\b";
    const HourNumRegex = "\\b(?<hournum>zero|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)\\b";
    const MinuteNumRegex = "(((?<tens>twenty|thirty|fou?rty|fifty)(\\s*-?\\s*))?(?<minnum>one|two|three|four|five|six|seven|eight|nine)|(?<minnum>ten|eleven|twelve|thirteen|fifteen|eighteen|(four|six|seven|nine)(teen)|twenty|thirty|forty|fifty))";
    const DeltaMinuteNumRegex = "(((?<tens>twenty|thirty|fou?rty|fifty)(\\s*-?\\s*))?(?<deltaminnum>one|two|three|four|five|six|seven|eight|nine)|(?<deltaminnum>ten|eleven|twelve|thirteen|fifteen|eighteen|(four|six|seven|nine)(teen)|twenty|thirty|forty|fifty))";
    const PmRegex = "(?<pm>(((?:at|in|around|circa|on|for)\\s+(the\\s+)?)?(((early|late)\\s+)?(afternoon|evening)|midnight|lunchtime))|((at|in|around|on|for)\\s+(the\\s+)?night))";
    const PmRegexFull = "(?<pm>((?:at|in|around|circa|on|for)\\s+(the\\s+)?)?(((early|late)\\s+)?(afternoon|evening)|(mid)?night|lunchtime))";
    const AmRegex = "(?<am>((?:at|in|around|circa|on|for)\\s+(the\\s+)?)?((early|late)\\s+)?(morning))";
    const LunchRegex = "\\blunchtime\\b";
    const NightRegex = "\\b(mid)?night\\b";
    const CommonDatePrefixRegex = "^[\\.]";
    const LessThanOneHour: string;
    const WrittenTimeRegex: string;
    const TimePrefix: string;
    const TimeSuffix: string;
    const TimeSuffixFull: string;
    const BasicTime: string;
    const MidnightRegex = "(?<midnight>mid\\s*(-\\s*)?night)";
    const MidmorningRegex = "(?<midmorning>mid\\s*(-\\s*)?morning)";
    const MidafternoonRegex = "(?<midafternoon>mid\\s*(-\\s*)?afternoon)";
    const MiddayRegex = "(?<midday>mid\\s*(-\\s*)?day|((12\\s)?noon))";
    const MidTimeRegex: string;
    const AtRegex: string;
    const IshRegex: string;
    const TimeUnitRegex = "([^a-z]{1,}|\\b)(?<unit>(h(ou)?r|min(ute)?|sec(ond)?)(?<plural>s)?|h)\\b";
    const RestrictedTimeUnitRegex = "(?<unit>hour|minute)\\b";
    const FivesRegex = "(?<tens>(?:fifteen|(?:twen|thir|fou?r|fif)ty(\\s*five)?|ten|five))\\b";
    const HourRegex: string;
    const PeriodHourNumRegex = "\\b(?<hour>twenty(\\s+(one|two|three|four))?|eleven|twelve|thirteen|fifteen|eighteen|(four|six|seven|nine)(teen)?|zero|one|two|three|five|eight|ten)\\b";
    const ConnectNumRegex: string;
    const TimeRegexWithDotConnector: string;
    const TimeRegex1: string;
    const TimeRegex2: string;
    const TimeRegex3: string;
    const TimeRegex4: string;
    const TimeRegex5: string;
    const TimeRegex6: string;
    const TimeRegex7: string;
    const TimeRegex8 = ".^";
    const TimeRegex9: string;
    const TimeRegex10: string;
    const TimeRegex11: string;
    const FirstTimeRegexInTimeRange: string;
    const PureNumFromTo: string;
    const PureNumBetweenAnd: string;
    const SpecificTimeFromTo: string;
    const SpecificTimeBetweenAnd: string;
    const SuffixAfterRegex = "\\b(((at)\\s)?(or|and)\\s+(above|after|later|greater)(?!\\s+than))\\b";
    const PrepositionRegex = "(?<prep>^(,\\s*)?(at|on|of)(\\s+the)?$)";
    const LaterEarlyRegex = "((?<early>earl(y|ier)(\\s+|-))|(?<late>late(r?\\s+|-)))";
    const MealTimeRegex = "\\b(at\\s+)?(?<mealTime>breakfast|brunch|lunch(\\s*time)?|dinner(\\s*time)?|supper)\\b";
    const UnspecificTimePeriodRegex: string;
    const TimeOfDayRegex: string;
    const SpecificTimeOfDayRegex: string;
    const TimeFollowedUnit: string;
    const TimeNumberCombinedWithUnit: string;
    const BusinessHourSplitStrings: string[];
    const NowRegex = "\\b(?<now>(right\\s+)?now|as\\s+soon\\s+as\\s+possible|asap|recently|previously|at\\s+(present|this\\s+time|th(e|is)\\s+minute|the\\s+(moment|present\\s+time)))\\b";
    const NowParseRegex: string;
    const SuffixRegex = "^\\s*(in the\\s+)?(morning|afternoon|evening|night)\\b";
    const NonTimeContextTokens = "(building)";
    const DateTimeTimeOfDayRegex = "\\b(?<timeOfDay>morning|(?<pm>afternoon|night|evening))\\b";
    const DateTimeSpecificTimeOfDayRegex: string;
    const TimeOfTodayAfterRegex: string;
    const TimeOfTodayBeforeRegex: string;
    const SimpleTimeOfTodayAfterRegex: string;
    const SimpleTimeOfTodayBeforeRegex: string;
    const SpecificEndOfRegex = "(the\\s+)?end of(\\s+the)?\\s*$";
    const UnspecificEndOfRegex = "\\b(the\\s+)?(eod|(end\\s+of\\s+day))\\b";
    const UnspecificEndOfRangeRegex = "\\b(eoy)\\b";
    const PeriodTimeOfDayRegex: string;
    const PeriodSpecificTimeOfDayRegex: string;
    const PeriodTimeOfDayWithDateRegex: string;
    const TasksmodeMealTimeofDayRegex = "\\b((in\\s+(the)?\\s+)?((?<early>earl(y|ier)(\\s+|-))|(?<late>late(r?\\s+|-)))?((this\\s+)?\\b(?<timeOfDay>lunch(\\s*time)?|dinner(\\s*time)?|brunch|breakfast)\\b))\\b";
    const LessThanRegex = "\\b(less\\s+than)\\b";
    const MoreThanRegex = "\\b(more\\s+than)\\b";
    const DurationUnitRegex: string;
    const SuffixAndRegex = "(?<suffix>\\s*(and)\\s+(an?\\s+)?(?<suffix_num>half|quarter))";
    const PeriodicRegex = "\\b(?<periodic>((?<multiplier>semi|bi|tri)(\\s*|-))?(daily|monthly|weekly|quarterly|yearly|annual(ly)?))\\b";
    const EachUnitRegex: string;
    const EachPrefixRegex = "\\b(?<each>(each|every|once an?)\\s*$)";
    const SetEachRegex = "\\b(?<each>(each|every)(?<other>\\s+(other|alternate))?\\s*)(?!the|that)\\b";
    const SetLastRegex: string;
    const EachDayRegex = "\\s*((each|every)\\s*day)|daily\\b";
    const DurationFollowedUnit: string;
    const NumberCombinedWithDurationUnit: string;
    const AnUnitRegex: string;
    const DuringRegex = "\\b(for|during)\\s+the\\s+(?<unit>year|month|week|day|fortnight)\\b";
    const AllRegex = "\\b(?<all>(all|full|whole)(\\s+|-)(?<unit>year|month|week|day|fortnight))\\b";
    const HalfRegex = "((an?\\s*)|\\b)(?<half>half\\s+(?<unit>year|month|week|fortnight|day|hour))\\b";
    const ConjunctionRegex = "\\b((and(\\s+for)?)|with)\\b";
    const HolidayList1 = "(?<holiday>mardi gras|(washington|mao)'s birthday|juneteenth|(jubilee|freedom)(\\s+day)|chinese new year|(new\\s+(years'|year\\s*'s|years?)\\s+eve)|(new\\s+(years'|year\\s*'s|years?)(\\s+day)?)|may\\s*day|yuan dan|christmas eve|(christmas|xmas)(\\s+day)?|black friday|yuandan|easter(\\s+(sunday|saturday|monday))?|clean monday|ash wednesday|palm sunday|maundy thursday|good friday|white\\s+(sunday|monday)|trinity sunday|pentecost|corpus christi|cyber monday)";
    const HolidayList2 = "(?<holiday>(thanks\\s*giving|all saint's|white lover|s(?:ain)?t?(\\.)?\\s+(?:patrick|george)(?:')?(?:s)?|us independence|all hallow|all souls|guy fawkes|cinco de mayo|halloween|qingming|dragon boat|april fools|tomb\\s*sweeping)(\\s+day)?)";
    const HolidayList3 = "(?<holiday>(?:independence|presidents(?:')?|mlk|martin luther king( jr)?|canberra|ascension|columbus|tree( planting)?|arbor|labou?r|((international|int'?l)\\s+)?workers'?|mother'?s?|father'?s?|female|women('s)?|single|teacher'?s|youth|children|girls|lovers?|earth|inauguration|groundhog|valentine'?s|baptiste|bastille|veterans(?:')?|memorial|mid[ \\-]autumn|moon|spring|lantern)\\s+day)";
    const HolidayList4 = "(?<holiday>ramad(h)?an|ram(a)?zan|ramathan|eid al(-|\\s+)adha|eid al(-|\\s+)azha|eidul(-|\\s+)azha|feast of the sacrifice|(islamic|arabic|hijri) new year|eid al(-|\\s+)fitr|festival of breaking the fast)";
    const HolidayRegex: string;
    const TasksModeHolidayListSupression = "(?<holiday>(?:independence|teacher'?s|youth|children|girls)\\s+day)|(?<holiday>ramad(h)?an|ram(a)?zan|ramathan|eid al(-|\\s+)adha|eid al(-|\\s+)azha|eidul(-|\\s+)azha|feast of the sacrifice|(islamic|arabic|hijri) new year|eid al(-|\\s+)fitr|festival of breaking the fast)\\b";
    const AMTimeRegex = "(?<am>morning)";
    const PMTimeRegex = "\\b(?<pm>afternoon|evening|night)\\b";
    const NightTimeRegex = "(night)";
    const NowTimeRegex = "(now|at\\s+(present|this\\s+time|th(e|is)\\s+minute|the\\s+(moment|(current|present)\\s+time)))";
    const RecentlyTimeRegex = "(recently|previously)";
    const AsapTimeRegex = "(as soon as possible|asap)";
    const InclusiveModPrepositions = "(?<include>((on|in|at)\\s+or\\s+)|(\\s+or\\s+(on|in|at)))";
    const AroundRegex = "(?:\\b(?:around|circa)\\s*?\\b)(\\s+the)?";
    const BeforeRegex: string;
    const AfterRegex: string;
    const SinceRegex = "(?:(?:\\b(?:since|after\\s+or\\s+equal\\s+to|(starting|beginning)(\\s)?(?:from|on|with)?|as\\s+early\\s+as|(any\\s+time\\s+)from)\\b\\s*?)|(?<!\\w|<)(>=))(\\s+the)?";
    const SinceRegexExp: string;
    const AgoRegex = "\\b(ago|earlier|before\\s+(?<day>yesterday|today))\\b";
    const LaterRegex: string;
    const BeforeAfterRegex = "\\b((?<before>before)|(?<after>from|after))\\b";
    const ModPrefixRegex: string;
    const ModSuffixRegex: string;
    const InConnectorRegex = "\\b(in)\\b";
    const SinceYearSuffixRegex: string;
    const WithinNextPrefixRegex: string;
    const TodayNowRegex = "\\b(today|now|current (date|time))\\b";
    const MorningStartEndRegex: string;
    const AfternoonStartEndRegex: string;
    const EveningStartEndRegex = "(^(evening))|((evening)$)";
    const NightStartEndRegex = "(^(over|to)?ni(ght|te))|((over|to)?ni(ght|te)$)";
    const InexactNumberRegex = "\\b((a\\s+)?few|some|several|(?<NumTwoTerm>(a\\s+)?couple(\\s+of)?))\\b";
    const InexactNumberUnitRegex: string;
    const RelativeTimeUnitRegex: string;
    const RelativeDurationUnitRegex: string;
    const ReferenceDatePeriodRegex: string;
    const ConnectorRegex = "^(-|,|for|t|around|circa|@)$";
    const FromToRegex = "(\\b(from).+(to|and|or)\\b.+)";
    const SingleAmbiguousMonthRegex = "^(the\\s+)?(may|march)$";
    const SingleAmbiguousTermsRegex = "^(the\\s+)?(day|week|month|year)$";
    const UnspecificDatePeriodRegex = "^(week|fortnight|month|year)$";
    const PrepositionSuffixRegex = "\\b(on|in|at|around|circa|from|to)$";
    const FlexibleDayRegex = "(?<DayOfMonth>([A-Za-z]+\\s)?[A-Za-z\\d]+)";
    const ForTheRegex: string;
    const WeekDayAndDayOfMonthRegex: string;
    const WeekDayAndDayRegex: string;
    const RestOfDateRegex = "\\b(rest|remaining)\\s+(of\\s+)?((the|my|this|current)\\s+)?(?<duration>week|fortnight|month|year|decade)\\b";
    const RestOfDateTimeRegex = "\\b(rest|remaining)\\s+(of\\s+)?((the|my|this|current)\\s+)?(?<unit>day)\\b";
    const AmbiguousRangeModifierPrefix = "(from)";
    const NumberEndingPattern: string;
    const OneOnOneRegex = "\\b(1\\s*:\\s*1(?!\\d))|(one (on )?one|one\\s*-\\s*one|one\\s*:\\s*one)\\b";
    const LaterEarlyPeriodRegex: string;
    const WeekWithWeekDayRangeRegex: string;
    const GeneralEndingRegex = "^\\s*((\\.,)|\\.|,|!|\\?)?\\s*$";
    const MiddlePauseRegex = "\\s*(,)\\s*";
    const DurationConnectorRegex = "^\\s*(?<connector>\\s+|and|,)\\s*$";
    const PrefixArticleRegex = "\\bthe\\s+";
    const OrRegex = "\\s*((\\b|,\\s*)(or|and)\\b|,)\\s*";
    const SpecialYearTermsRegex: string;
    const YearPlusNumberRegex: string;
    const NumberAsTimeRegex: string;
    const TimeBeforeAfterRegex: string;
    const DateNumberConnectorRegex = "^\\s*(?<connector>\\s+at)\\s*$";
    const DecadeRegex = "(?<decade>(?:nough|twen|thir|fou?r|fif|six|seven|eigh|nine)ties|two\\s+thousands)";
    const DecadeWithCenturyRegex: string;
    const RelativeDecadeRegex: string;
    const YearPeriodRegex: string;
    const StrictTillRegex: string;
    const StrictRangeConnectorRegex: string;
    const StartMiddleEndRegex = "\\b((?<StartOf>((the\\s+)?(start|beginning)\\s+of\\s+)?)(?<MiddleOf>((the\\s+)?middle\\s+of\\s+)?)(?<EndOf>((the\\s+)?end\\s+of\\s+)?))";
    const ComplexDatePeriodRegex: string;
    const FailFastRegex: string;
    const TasksModeSupressionRegexes: string;
    const TasksModeNextPrefix = "(?<next>next\\s+)";
    const TasksModeDurationToDatePatterns: string;
    const UnitMap: ReadonlyMap<string, string>;
    const UnitValueMap: ReadonlyMap<string, number>;
    const SpecialYearPrefixesMap: ReadonlyMap<string, string>;
    const SeasonMap: ReadonlyMap<string, string>;
    const SeasonValueMap: ReadonlyMap<string, number>;
    const CardinalMap: ReadonlyMap<string, number>;
    const DayOfWeek: ReadonlyMap<string, number>;
    const MonthOfYear: ReadonlyMap<string, number>;
    const Numbers: ReadonlyMap<string, number>;
    const DayOfMonth: ReadonlyMap<string, number>;
    const DoubleNumbers: ReadonlyMap<string, number>;
    const HolidayNames: ReadonlyMap<string, string[]>;
    const WrittenDecades: ReadonlyMap<string, number>;
    const SpecialDecadeCases: ReadonlyMap<string, number>;
    const DefaultLanguageFallback = "MDY";
    const SuperfluousWordList: string[];
    const DurationDateRestrictions: string[];
    const AmbiguityFiltersDict: ReadonlyMap<string, string>;
    const AmbiguityTimeFiltersDict: ReadonlyMap<string, string>;
    const AmbiguityDurationFiltersDict: ReadonlyMap<string, string>;
    const MorningTermList: string[];
    const AfternoonTermList: string[];
    const EveningTermList: string[];
    const MealtimeBreakfastTermList: string[];
    const MealtimeBrunchTermList: string[];
    const MealtimeLunchTermList: string[];
    const MealtimeDinnerTermList: string[];
    const DaytimeTermList: string[];
    const NightTermList: string[];
    const NighttimeTermList: string[];
    const SameDayTerms: string[];
    const PlusOneDayTerms: string[];
    const MinusOneDayTerms: string[];
    const PlusTwoDayTerms: string[];
    const MinusTwoDayTerms: string[];
    const FutureTerms: string[];
    const LastCardinalTerms: string[];
    const MonthTerms: string[];
    const MonthToDateTerms: string[];
    const WeekendTerms: string[];
    const WeekTerms: string[];
    const FortnightTerms: string[];
    const YearTerms: string[];
    const GenericYearTerms: string[];
    const YearToDateTerms: string[];
    const DoubleMultiplierRegex = "^(bi)(-|\\s)?";
    const HalfMultiplierRegex = "^(semi)(-|\\s)?";
    const DayTypeRegex = "((week)?da(il)?ys?)$";
    const WeekDayTypeRegex = "(weekday?)$";
    const FortNightRegex = "(fortnight?)$";
    const WeekTypeRegex = "(week(s|ly)?)$";
    const WeekendTypeRegex = "(weekends?)$";
    const MonthTypeRegex = "(month(s|ly)?)$";
    const QuarterTypeRegex = "(quarter(s|ly)?)$";
    const YearTypeRegex = "((years?|annual)(ly)?)$";
}