export declare namespace SpanishDateTime {
    const LangMarker = "Spa";
    const CheckBothBeforeAfter = false;
    const TillRegex: string;
    const StrictTillRegex: string;
    const RangeConnectorRegex: string;
    const WrittenDayRegex = "(?<day>uno|dos|tres|cuatro|cinco|seis|siete|ocho|nueve|diez|once|doce|trece|catorce|quince|diecis\u00E9is|diecisiete|dieciocho|diecinueve|veinte|veintiuno|veintid\u00F3s|veintitr\u00E9s|veinticuatro|veinticinco|veintis\u00E9is|veintisiete|veintiocho|veintinueve|treinta(\\s+y\\s+uno)?)";
    const DayRegex = "\\b(?<day>01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|1|20|21|22|23|24|25|26|27|28|29|2|30|31|3|4|5|6|7|8|9)(?:\\.[\u00BA\u00B0])?(?=\\b|t)";
    const MonthNumRegex = "(?<month>1[0-2]|(0)?[1-9])\\b";
    const OclockRegex = "(?<oclock>en\\s+punto)";
    const AmDescRegex: string;
    const PmDescRegex: string;
    const AmPmDescRegex: string;
    const DescRegex: string;
    const OfPrepositionRegex = "(\\bd(o|al?|el?)\\b)";
    const AfterNextSuffixRegex = "\\b(despu[e\u00E9]s\\s+de\\s+la\\s+pr[o\u00F3]xima)\\b";
    const NextSuffixRegex = "\\b(que\\s+viene|pr[o\u00F3]xim[oa]|siguiente)\\b";
    const PreviousSuffixRegex = "\\b(pasad[ao]|anterior(?!\\s+(al?|del?)\\b))\\b";
    const RelativeSuffixRegex: string;
    const RangePrefixRegex = "((de(l|sde)?|entre)(\\s+la(s)?)?)";
    const TwoDigitYearRegex: string;
    const RelativeRegex = "(?<order>est[ae]s?|pr[o\u00F3]xim[oa]s?|siguiente|(([u\u00FA]ltim|pasad)[ao]s?))\\b";
    const StrictRelativeRegex = "(?<order>est[ae]|pr[o\u00F3]xim[oa]|siguiente|(([u\u00FA]ltim|pasad)(o|as|os)))\\b";
    const WrittenOneToNineRegex = "(un[ao]?|dos|tres|cuatro|cinco|seis|siete|ocho|nueve)";
    const WrittenOneHundredToNineHundredRegex = "(doscient[oa]s|trescient[oa]s|cuatrocient[ao]s|quinient[ao]s|seiscient[ao]s|setecient[ao]s|ochocient[ao]s|novecient[ao]s|cien(to)?)";
    const WrittenOneToNinetyNineRegex: string;
    const FullTextYearRegex: string;
    const YearRegex: string;
    const RelativeMonthRegex = "(?<relmonth>(de\\s+)?((este|pr[o\u00F3]ximo|([u\u00FA]ltim(o|as|os)))\\s+mes)|(del\\s+)?(mes\\s+((que\\s+viene)|pasado)))\\b";
    const MonthRegex = "\\b(?<month>abr(\\.|(il)?\\b)|ago(\\.|(sto)?\\b)|dic(\\.|(iembre)?\\b)|feb(\\.|(rero)?\\b)|ene(\\.|(ro)?\\b)|ju[ln](\\.|(io)?\\b)|mar(\\.|(zo)?\\b)|may(\\.|(o)?\\b)|nov(\\.|(iembre)?\\b)|oct(\\.|(ubre)?\\b)|sep?t(\\.|(iembre)?\\b)|sep(\\.|\\b))";
    const MonthSuffixRegex: string;
    const DateUnitRegex = "(?<unit>(a\u00F1o|(?<uoy>semana))(?<plural>s)?|(?<uoy>mes)(?<plural>es)?|(?<uoy>d[i\u00ED]a)(?<plural>s)?(?<business>\\s+(h[a\u00E1]biles|laborales))?)\\b";
    const PastRegex = "(?<past>\\b(pasad(a|o)(s)?|[u\u00FA]ltim[oa](s)?|anterior(es)?|previo(s)?)\\b)";
    const FutureRegex = "\\b(siguiente(s)?|pr[o\u00F3]xim[oa](s)?)\\b";
    const SimpleCasesRegex: string;
    const MonthFrontSimpleCasesRegex: string;
    const MonthFrontBetweenRegex: string;
    const DayBetweenRegex: string;
    const SpecialYearPrefixes = "((del\\s+)?calend[a\u00E1]rio|(?<special>fiscal|escolar))";
    const OneWordPeriodRegex: string;
    const MonthWithYearRegex: string;
    const MonthNumWithYearRegex: string;
    const WeekOfMonthRegex: string;
    const WeekOfYearRegex: string;
    const OfYearRegex: string;
    const FirstLastRegex = "\\b((el|las?|los?)\\s+)?((?<first>primer([ao]s?)?)|(?<last>[u\u00FA]ltim[ao]s?))\\b";
    const FollowedDateUnit: string;
    const NumberCombinedWithDateUnit: string;
    const QuarterTermRegex = "\\b((?<cardinal>primer|1er|segundo|2do|tercer|3ro|4to|([1234](\\.)?\u00BA))\\s+(trimestre|cuarto)|[tq](?<number>[1-4]))\\b";
    const RelativeQuarterTermRegex: string;
    const QuarterRegex: string;
    const QuarterRegexYearFront: string;
    const AllHalfYearRegex: string;
    const EarlyPrefixRegex: string;
    const MidPrefixRegex: string;
    const LaterPrefixRegex: string;
    const PrefixPeriodRegex: string;
    const PrefixDayRegex: string;
    const CenturySuffixRegex = "(^siglo)\\b";
    const SeasonRegex: string;
    const WhichWeekRegex: string;
    const WeekOfRegex: string;
    const MonthOfRegex: string;
    const RangeUnitRegex = "\\b(?<unit>a\u00F1os?|mes(es)?|semanas?)\\b";
    const BeforeAfterRegex = "^[.]";
    const InConnectorRegex = "\\b(en)(?=\\s*$)\\b";
    const TodayNowRegex = "\\b(hoy|ahora|este entonces)\\b";
    const FromRegex = "((\\bde(sde)?)(\\s*la(s)?)?)$";
    const BetweenRegex = "(\\bentre\\s*(la(s)?)?)";
    const WeekDayRegex = "\\b(?<weekday>(domingos?|lunes|martes|mi[e\u00E9]rcoles|jueves|viernes|s[a\u00E1]bados?)\\b|(lun|mar|mi[e\u00E9]|jue|vie|s[a\u00E1]b|dom|lu|ma|mi|ju|vi|s[a\u00E1]|do)(\\.|\\b))(?!\u00F1)";
    const OnRegex: string;
    const RelaxedOnRegex = "(?<=\\b(en|d?el)\\s+)((?<day>10|11|12|13|14|15|16|17|18|19|1st|20|21|22|23|24|25|26|27|28|29|2|30|31|3|4|5|6|7|8|9)s?)(?![.,]\\d)\\b";
    const SpecialDayRegex = "\\b((el\\s+)?(d[i\u00ED]a\\s+antes\\s+de\\s+ayer|anteayer)|((el\\s+)?d[i\u00ED]a\\s+(despu[e\u00E9]s\\s+)?de\\s+ma\u00F1ana|pasado\\s+ma\u00F1ana)|(el\\s)?d[i\u00ED]a\\s+(siguiente|anterior)|(el\\s)?pr[o\u00F3]ximo\\s+d[i\u00ED]a|(el\\s+)?[u\u00FA]ltimo\\s+d[i\u00ED]a|(d)?el\\s+d[i\u00ED]a(?!\\s+(de|internacional))|ayer|ma\u00F1ana|hoy)\\b";
    const SpecialDayWithNumRegex = "^[.]";
    const FlexibleDayRegex: string;
    const ForTheRegex: string;
    const WeekDayAndDayOfMonthRegex: string;
    const WeekDayAndDayRegex: string;
    const WeekDayOfMonthRegex: string;
    const RelativeWeekDayRegex = "^[.]";
    const AmbiguousRangeModifierPrefix = "^[.]";
    const NumberEndingPattern = "^[.]";
    const DateTokenPrefix = "en ";
    const TimeTokenPrefix = "a las ";
    const TokenBeforeDate = "el ";
    const TokenBeforeTime = "a las ";
    const HalfTokenRegex = "^((y\\s+)?media)";
    const QuarterTokenRegex = "^((y\\s+)?cuarto|(?<neg>menos\\s+cuarto))";
    const PastTokenRegex = "\\b(pasad[ao]s(\\s+(de\\s+)?las)?)$";
    const ToTokenRegex = "\\b((para|antes)(\\s+(de\\s+)?las?)|(?<neg>^menos))$";
    const SpecialDateRegex: string;
    const OfMonthRegex: string;
    const MonthEndRegex: string;
    const WeekDayEnd: string;
    const WeekDayStart = "^\\b$";
    const DateYearRegex: string;
    const DateExtractor1: string;
    const DateExtractor2: string;
    const DateExtractor3: string;
    const DateExtractor4: string;
    const DateExtractor5: string;
    const DateExtractor6: string;
    const DateExtractor7: string;
    const DateExtractor8: string;
    const DateExtractor9: string;
    const DateExtractor10: string;
    const HourRegex = "\\b(?<!\\d[,.])(?<hour>2[0-4]|[0-1]?\\d)";
    const HourNumRegex = "\\b(?<hournum>cero|una|dos|tres|cuatro|cinco|seis|siete|ocho|nueve|diez|once|doce)\\b";
    const MinuteNumRegex = "(?<minnum>uno?|d[\u00F3o]s|tr[e\u00E9]s|cuatro|cinco|s[e\u00E9]is|siete|ocho|nueve|diez|once|doce|trece|catorce|quince|diecis[e\u00E9]is|diecisiete|dieciocho|diecinueve|veinte|treinta|cuarenta|cincuenta)";
    const DeltaMinuteNumRegex = "(?<deltaminnum>uno?|d[\u00F3o]s|tr[e\u00E9]s|cuatro|cinco|s[e\u00E9]is|siete|ocho|nueve|diez|once|doce|trece|catorce|quince|diecis[e\u00E9]is|diecisiete|dieciocho|diecinueve|veinte|treinta|cuarenta|cincuenta)";
    const PmRegex = "(?<pm>((por|de|a|en)\\s+la)\\s+(tarde|noche))";
    const AmRegex = "(?<am>((por|de|a|en)\\s+la)\\s+(ma\u00F1ana|madrugada))";
    const AmTimeRegex = "(?<am>(esta|(por|de|a|en)\\s+la)\\s+(ma\u00F1ana|madrugada))";
    const PmTimeRegex = "(?<pm>(esta|(por|de|a|en)\\s+la)\\s+(tarde|noche))";
    const NightTimeRegex = "(noche)";
    const LastNightTimeRegex = "(anoche)";
    const NowTimeRegex = "(ahora|mismo|momento)";
    const RecentlyTimeRegex = "(mente)";
    const AsapTimeRegex = "(posible|pueda[ns]?|podamos)";
    const LessThanOneHour: string;
    const TensTimeRegex = "(?<tens>diez|veint(i|e)|treinta|cuarenta|cincuenta)";
    const WrittenTimeRegex: string;
    const TimePrefix: string;
    const TimeSuffix: string;
    const GeneralDescRegex: string;
    const BasicTime: string;
    const MidTimeRegex = "(?<mid>((?<midnight>media\\s*noche)|(?<midearlymorning>media\\s*madrugada)|(?<midmorning>media\\s*ma\u00F1ana)|(?<midafternoon>media\\s*tarde)|(?<midday>medio\\s*d[i\u00ED]a)))";
    const AtRegex: string;
    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: string;
    const TimeRegex9: string;
    const TimeRegex11: string;
    const TimeRegex12: string;
    const PrepositionRegex = "(?<prep>^(,\\s*)?(a(l)?|en|de(l)?)?(\\s*(la(s)?|el|los))?$)";
    const LaterEarlyRegex = "((?<early>temprano)|(?<late>fin(al)?(\\s+de)?|m[a\u00E1]s\\s+tarde))";
    const NowRegex = "\\b(?<now>(justo\\s+)?ahora(\\s+mismo)?|en\\s+este\\s+momento|tan\\s+pronto\\s+como\\s+sea\\s+posible|tan\\s+pronto\\s+como\\s+(pueda|puedas|podamos|puedan)|lo\\s+m[a\u00E1]s\\s+pronto\\s+posible|recientemente|previamente|este entonces)\\b";
    const SuffixRegex = "^\\s*(((y|a|en|por)\\s+la|al)\\s+)?(ma\u00F1ana|madrugada|medio\\s*d[i\u00ED]a|(?<!(m[\u00E1a]s\\s+))tarde|noche)\\b";
    const TimeOfDayRegex: string;
    const SpecificTimeOfDayRegex: string;
    const TimeOfTodayAfterRegex: string;
    const TimeOfTodayBeforeRegex: string;
    const NonTimeContextTokens = "(edificio)";
    const SimpleTimeOfTodayAfterRegex: string;
    const SimpleTimeOfTodayBeforeRegex: string;
    const SpecificEndOfRegex = "((a|e)l\\s+)?fin(alizar|al)?(\\s+(el|de(l)?)(\\s+d[i\u00ED]a)?(\\s+de)?)?\\s*$";
    const UnspecificEndOfRegex = "\\b([ae]l\\s+)?(fin(al)?\\s+del?\\s+d[i\u00ED]a)\\b";
    const UnspecificEndOfRangeRegex = "^[.]";
    const DateTimeTimeOfDayRegex = "\\b(?<timeOfDay>ma\u00F1ana|madrugada|(?<pm>pasado\\s+(el\\s+)?medio\\s?d[i\u00ED]a|tarde|noche))\\b";
    const PeriodTimeOfDayRegex: string;
    const PeriodSpecificTimeOfDayRegex: string;
    const UnitRegex = "(?<unit>a\u00F1os?|(bi|tri|cuatri|se)mestre|mes(es)?|semanas?|fin(es)?\\s+de\\s+semana|finde|d[i\u00ED]as?|horas?|hra?s?|hs?|minutos?|mins?|segundos?|segs?|noches?)\\b";
    const ConnectorRegex = "^(,|t|(para|y|a|en|por) las?|(\\s*,\\s*)?((cerca|alrededor)\\s+)?(de\\s+las?|del))$";
    const TimeHourNumRegex = "(?<hour>veint(i(uno|dos|tres|cuatro)|e)|cero|uno|dos|tres|cuatro|cinco|seis|siete|ocho|nueve|diez|once|doce|trece|catorce|quince|dieci(s([e\u00E9])is|siete|ocho|nueve))";
    const PureNumFromTo: string;
    const PureNumBetweenAnd: string;
    const SpecificTimeFromTo: string;
    const SpecificTimeBetweenAnd: string;
    const TimeUnitRegex = "([^A-Za-z]{1,}|\\b)(?<unit>(hora|minuto|min|segundo|se[cg])(?<plural>s)?|h)\\b";
    const TimeFollowedUnit: string;
    const TimeNumberCombinedWithUnit: string;
    const DateTimePeriodNumberCombinedWithUnit: string;
    const PeriodTimeOfDayWithDateRegex: string;
    const RelativeTimeUnitRegex: string;
    const LessThanRegex = "\\b(dentro\\s+de\\s+menos\\s+de)\\b";
    const MoreThanRegex = "\\b(durante\\s+(m[\u00E1a]s\\s+)?de)\\b";
    const SuffixAndRegex = "(?<suffix>\\s*(y)\\s+((un[ao]?)\\s+)?(?<suffix_num>media|cuarto))";
    const FollowedUnit: string;
    const DurationNumberCombinedWithUnit: string;
    const AnUnitRegex: string;
    const DuringRegex = "^[.]";
    const AllRegex = "\\b(?<all>tod[oa]?\\s+(el|la)\\s+(?<unit>a\u00F1o|mes|semana|d[i\u00ED]a)|((una?|el|la)\\s+)?(?<unit>a\u00F1o|mes|semana|d[i\u00ED]a)\\s+enter[ao])\\b";
    const HalfRegex = "\\b(?<half>medi[oa]\\s+(?<unit>ano|mes|semana|d[\u00EDi]a|hora))\\b";
    const ConjunctionRegex = "^[.]";
    const InexactNumberRegex = "\\b(pocos?|algo|vari[ao]s|algun[ao]s|un[ao]s)\\b";
    const InexactNumberUnitRegex: string;
    const HolidayRegex1: string;
    const HolidayRegex2: string;
    const HolidayRegex3: string;
    const BeforeRegex = "(\\b((ante(s|rior)|m[a\u00E1]s\\s+temprano|no\\s+m[a\u00E1]s\\s+tard(e|ar)|hasta|(?<include>tan\\s+tarde\\s+como))(\\s+(del?|a|que)(\\s+(el|las?|los?))?)?)|(?<!\\w|>)((?<include><\\s*=)|<))";
    const AfterRegex = "((\\b(despu[e\u00E9]s|(a\u00F1o\\s+)?posterior|m[a\u00E1]s\\s+tarde|a\\s+primeros)(\\s*(del?|en|a)(\\s+(el|las?|los?))?)?|(empi?en?zando|comenzando)(\\s+(el|las?|los?))?)\\b|(?<!\\w|<)((?<include>>\\s*=)|>))";
    const SinceRegex = "\\b(((cualquier\\s+tiempo\\s+)?(desde|a\\s+partir\\s+del?)|tan\\s+(temprano|pronto)\\s+como(\\s+(de|a))?)(\\s+(el|las?|los?))?)\\b";
    const SinceRegexExp: string;
    const AroundRegex = "(?:\\b(?:cerca|alrededor|aproximadamente)(\\s+(de\\s+(las?|el)|del?))?\\s*\\b)";
    const PeriodicRegex = "\\b(?<periodic>a\\s*diario|diaria(s|mente)|(bi|tri)?(semanal|quincenal|mensual|(se|tri)mestral|anual)(es|mente)?)\\b";
    const EachExpression = "\\b(cada|tod[oa]s\\s*(l[oa]s)?)\\b\\s*(?!\\s*l[oa]\\b)";
    const EachUnitRegex: string;
    const EachPrefixRegex: string;
    const EachDayRegex: string;
    const BeforeEachDayRegex: string;
    const SetEachRegex: string;
    const LaterEarlyPeriodRegex: string;
    const RelativeWeekRegex = "(((la|el)\\s+)?(((est[ae]|pr[o\u00F3]xim[oa]|[u\u00FA]ltim(o|as|os))\\s+semanas?)|(semanas?\\s+(que\\s+viene|pasad[oa]))))";
    const WeekWithWeekDayRangeRegex: string;
    const GeneralEndingRegex = "^\\s*((\\.,)|\\.|,|!|\\?)?\\s*$";
    const MiddlePauseRegex = "^[.]";
    const PrefixArticleRegex = "\\b(e[ln]\\s+(d[i\u00ED]a\\s+)?)";
    const OrRegex = "^[.]";
    const SpecialYearTermsRegex: string;
    const YearPlusNumberRegex: string;
    const NumberAsTimeRegex: string;
    const TimeBeforeAfterRegex: string;
    const DateNumberConnectorRegex = "^\\s*(?<connector>a\\s+las)\\s*$";
    const CenturyRegex = "^[.]";
    const DecadeRegex = "(?<decade>diez|veinte|treinta|cuarenta|cincuenta|se[st]enta|ochenta|noventa)";
    const DecadeWithCenturyRegex: string;
    const RelativeDecadeRegex: string;
    const ComplexDatePeriodRegex: string;
    const AmbiguousPointRangeRegex = "^(mar\\.?)$";
    const YearSuffix: string;
    const SinceYearSuffixRegex: string;
    const AgoRegex = "\\b(antes\\s+de\\s+(?<day>hoy|ayer|ma\u00F1ana)|antes|hace)\\b";
    const LaterRegex = "\\b(despu[e\u00E9]s(?!\\s+de\\b)|desde\\s+ahora|(a\\s+partir|despu[e\u00E9]s)\\s+de\\s+(ahora|(?<day>hoy|ayer|ma\u00F1ana)))\\b";
    const Tomorrow = "ma\u00F1ana";
    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 HolidayNames: ReadonlyMap<string, string[]>;
    const VariableHolidaysTimexDictionary: ReadonlyMap<string, string>;
    const DoubleNumbers: ReadonlyMap<string, number>;
    const UpcomingPrefixRegex = "((este\\s+))";
    const NextPrefixRegex: string;
    const PastPrefixRegex = "((este\\s+))";
    const PreviousPrefixRegex: string;
    const ThisPrefixRegex = "(est?[ea]|actual)\\b";
    const PrefixWeekDayRegex = "(\\s*((,?\\s*el)|[-\u2014\u2013]))";
    const ThisRegex: string;
    const LastDateRegex: string;
    const NextDateRegex: string;
    const RelativeDayRegex = "(?<relday>((este|pr[o\u00F3]ximo|([u\u00FA]ltim(o|as|os)))\\s+d\u00EDas)|(d\u00EDas\\s+((que\\s+viene)|pasado)))\\b";
    const RestOfDateRegex = "\\bresto\\s+((del|de)\\s+)?((la|el|est?[ae])\\s+)?(?<duration>semana|mes|a\u00F1o|decada)(\\s+actual)?\\b";
    const WithinNextPrefixRegex: string;
    const DurationUnitRegex: string;
    const DurationConnectorRegex = "^\\s*(?<connector>\\s+|y|,)\\s*$";
    const RelativeDurationUnitRegex: string;
    const ReferencePrefixRegex = "(mism[ao]|aquel|est?e)\\b";
    const ReferenceDatePeriodRegex: string;
    const FromToRegex = "\\b(from).+(to)\\b.+";
    const SingleAmbiguousMonthRegex = "^(the\\s+)?(may|march)$";
    const UnspecificDatePeriodRegex = "^[\\.]";
    const PrepositionSuffixRegex = "\\b(en|el|la|cerca|alrededor|desde|durante|hasta|hacia)$";
    const RestOfDateTimeRegex = "\\bresto\\s+((del?)\\s+)?((la|el|est[ae])\\s+)?(?<unit>(d\u00EDa|jornada))(\\s+de\\s+hoy)?\\b";
    const SetWeekDayRegex = "^[\\.]";
    const NightRegex = "\\b(medionoche|noche)\\b";
    const CommonDatePrefixRegex = "^[\\.]";
    const SuffixAfterRegex = "\\b((a\\s+)?(o|y)\\s+(arriba|despu[e\u00E9]s|posterior|mayor|m[a\u00E1]s\\s+tarde)(?!\\s+(que|de)))\\b";
    const YearPeriodRegex: string;
    const FutureSuffixRegex = "\\b(siguiente(s)?|pr[o\u00F3]xim[oa](s)?|(en\\s+el\\s+)?futuro)\\b";
    const PastSuffixRegex = "^\\b$";
    const ModPrefixRegex: string;
    const ModSuffixRegex: string;
    const WrittenDecades: ReadonlyMap<string, number>;
    const SpecialDecadeCases: ReadonlyMap<string, number>;
    const DefaultLanguageFallback = "DMY";
    const DurationDateRestrictions: string[];
    const AmbiguityFiltersDict: ReadonlyMap<string, string>;
    const EarlyMorningStartEndRegex = "(^(madrugada)|(madrugada)$)";
    const MorningStartEndRegex = "(^((la\\s+)?ma\u00F1ana))|(((la\\s+)?ma\u00F1ana)$)";
    const AfternoonStartEndRegex = "(^(pasado\\s+(el\\s+)?medio\\s*dia))|((pasado\\s+(el\\s+)?medio\\s*dia)$)";
    const EveningStartEndRegex = "(^(tarde))|((tarde)$)";
    const NightStartEndRegex = "(^(noche)|(noche)$)";
    const EarlyMorningTermList: string[];
    const MorningTermList: string[];
    const AfternoonTermList: string[];
    const EveningTermList: string[];
    const NightTermList: string[];
    const SameDayTerms: string[];
    const PlusOneDayTerms: string[];
    const MinusOneDayTerms: string[];
    const PlusTwoDayTerms: string[];
    const MinusTwoDayTerms: string[];
    const MonthTerms: string[];
    const MonthToDateTerms: string[];
    const WeekendTerms: string[];
    const WeekTerms: string[];
    const FortnightTerms: string[];
    const YearTerms: string[];
    const YearToDateTerms: string[];
    const SpecialCharactersEquivalent: ReadonlyMap<string, string>;
    const DoubleMultiplierRegex = "^(bi)(-|\\s)?";
    const DayTypeRegex = "(d[i\u00ED]as?|diari(o|as|amente))$";
    const WeekTypeRegex = "(semanas?|semanalmente)$";
    const BiWeekTypeRegex = "(quincenalmente)$";
    const WeekendTypeRegex = "(fin(es)?\\s+de\\s+semana|finde)$";
    const MonthTypeRegex = "(mes(es)?|mensual(es|mente)?)$";
    const QuarterTypeRegex = "(trimestral(es|mente)?)$";
    const SemiAnnualTypeRegex = "(semestral(es|mente)?)$";
    const YearTypeRegex = "(a\u00F1os?|anual(mente)?)$";
    const ThisTerms: string[];
}