mis-crystal-design-system 2.3.18 → 2.3.21

package/datepicker/sub-components/chronos/locale/locale.class.d.ts

@@ -0,0 +1,143 @@
+export interface LocaleOptionsFormat {
+    format: string[];
+    standalone: string[];
+    isFormat?: RegExp;
+}
+export declare type LocaleOptions = string[] | LocaleOptionsFormat;
+export declare const defaultLocaleMonths: string[];
+export declare const defaultLocaleMonthsShort: string[];
+export declare const defaultLocaleWeekdays: string[];
+export declare const defaultLocaleWeekdaysShort: string[];
+export declare const defaultLocaleWeekdaysMin: string[];
+export declare const defaultLongDateFormat: {
+    [index: string]: string;
+};
+export declare const defaultOrdinal = "%d";
+export declare const defaultDayOfMonthOrdinalParse: RegExp;
+export declare type OrdinalDateFn = (num: number, token?: string) => string;
+export declare type PluralizeDateFn = (num: number, withoutSuffix: boolean, key?: string, isFuture?: boolean) => string;
+export interface LocaleData {
+    abbr?: string;
+    parentLocale?: string;
+    months?: LocaleOptions | ((date: Date, format: string, isUTC?: boolean) => string | string[]);
+    monthsShort?: LocaleOptions | ((date: Date, format: string, isUTC?: boolean) => string | string[]);
+    monthsParseExact?: boolean;
+    weekdays?: LocaleOptions | ((date: Date, format: string, isUTC?: boolean) => string | string[]);
+    weekdaysShort?: string[] | ((date: Date, format: string, isUTC?: boolean) => string | string[]);
+    weekdaysMin?: string[] | ((date: Date, format: string, isUTC?: boolean) => string | string[]);
+    weekdaysParseExact?: boolean;
+    longDateFormat?: {
+        [index: string]: string;
+    };
+    calendar?: {
+        [key: string]: (string | ((date: Date, now?: Date) => string) | ((dayOfWeek: number, isNextWeek: boolean) => string));
+    };
+    relativeTime?: {
+        [key: string]: string | PluralizeDateFn;
+    };
+    dayOfMonthOrdinalParse?: RegExp;
+    ordinal?: string | OrdinalDateFn;
+    week?: {
+        dow?: number;
+        doy?: number;
+    };
+    invalidDate?: string;
+    monthsRegex?: RegExp;
+    monthsParse?: RegExp[];
+    monthsShortRegex?: RegExp;
+    monthsStrictRegex?: RegExp;
+    monthsShortStrictRegex?: RegExp;
+    longMonthsParse?: RegExp[];
+    shortMonthsParse?: RegExp[];
+    meridiemParse?: RegExp;
+    meridiemHour?(hour: number, meridiem: string): number;
+    preparse?(str: string, format?: string | string[]): string;
+    postformat?(str: string | number): string;
+    meridiem?(hour: number, minute?: number, isLower?: boolean): string;
+    isPM?(input: string): boolean;
+    getFullYear?(date: Date, isUTC: boolean): number;
+}
+export declare class Locale {
+    parentLocale?: Locale;
+    _abbr: string;
+    _config: LocaleData;
+    meridiemHour: (hour: number, meridiem: string) => number;
+    _invalidDate: string;
+    _week: {
+        dow: number;
+        doy: number;
+    };
+    _dayOfMonthOrdinalParse: RegExp;
+    _ordinalParse: RegExp;
+    _meridiemParse: RegExp;
+    private _calendar;
+    private _relativeTime;
+    private _months;
+    private _monthsShort;
+    private _monthsRegex;
+    private _monthsShortRegex;
+    private _monthsStrictRegex;
+    private _monthsShortStrictRegex;
+    private _monthsParse;
+    private _longMonthsParse;
+    private _shortMonthsParse;
+    private _monthsParseExact;
+    private _weekdaysParseExact;
+    private _weekdaysRegex;
+    private _weekdaysShortRegex;
+    private _weekdaysMinRegex;
+    private _weekdaysStrictRegex;
+    private _weekdaysShortStrictRegex;
+    private _weekdaysMinStrictRegex;
+    private _weekdays;
+    private _weekdaysShort;
+    private _weekdaysMin;
+    private _weekdaysParse;
+    private _minWeekdaysParse;
+    private _shortWeekdaysParse;
+    private _fullWeekdaysParse;
+    private _longDateFormat;
+    private _ordinal;
+    constructor(config: LocaleData);
+    set(config: LocaleData): void;
+    calendar(key: string, date: Date, now: Date): string;
+    longDateFormat(key: string): string;
+    get invalidDate(): string;
+    set invalidDate(val: string);
+    ordinal(num: number, token?: string): string;
+    preparse(str: string, format?: string | string[]): string;
+    getFullYear(date: Date, isUTC?: boolean): number;
+    postformat(str: string): string;
+    relativeTime(num: number, withoutSuffix: boolean, str: 'future' | 'past', isFuture: boolean): string;
+    pastFuture(diff: number, output: string): string;
+    /** Months */
+    months(): string[];
+    months(date: Date, format?: string, isUTC?: boolean): string;
+    monthsShort(): string[];
+    monthsShort(date?: Date, format?: string, isUTC?: boolean): string;
+    monthsParse(monthName: string, format?: string, strict?: boolean): number;
+    monthsRegex(isStrict: boolean): RegExp;
+    monthsShortRegex(isStrict: boolean): RegExp;
+    /** Week */
+    week(date: Date, isUTC?: boolean): number;
+    firstDayOfWeek(): number;
+    firstDayOfYear(): number;
+    /** Day of Week */
+    weekdays(): string[];
+    weekdays(date: Date, format?: string, isUTC?: boolean): string;
+    weekdaysMin(): string[];
+    weekdaysMin(date: Date, format?: string, isUTC?: boolean): string;
+    weekdaysShort(): string[];
+    weekdaysShort(date: Date, format?: string, isUTC?: boolean): string;
+    weekdaysParse(weekdayName?: string, format?: string, strict?: boolean): number;
+    weekdaysRegex(isStrict: boolean): RegExp;
+    weekdaysShortRegex(isStrict?: boolean): RegExp;
+    weekdaysMinRegex(isStrict?: boolean): RegExp;
+    isPM(input: string): boolean;
+    meridiem(hours: number, minutes: number, isLower: boolean): string;
+    formatLongDate(key: string): string;
+    private handleMonthStrictParse;
+    private handleWeekStrictParse;
+    private computeMonthsParse;
+    private computeWeekdaysParse;
+}

package/datepicker/sub-components/chronos/locale/locale.defaults.d.ts

@@ -0,0 +1,11 @@
+import { LocaleData } from './locale.class';
+export declare const defaultInvalidDate = "Invalid date";
+export declare const defaultLocaleWeek: {
+    dow: number;
+    doy: number;
+};
+export declare const defaultLocaleMeridiemParse: RegExp;
+export declare const defaultRelativeTime: {
+    [key: string]: string;
+};
+export declare const baseConfig: LocaleData;

package/datepicker/sub-components/chronos/locale/locales.d.ts

@@ -0,0 +1,7 @@
+import { Locale, LocaleData } from './locale.class';
+export declare function mergeConfigs(parentConfig: LocaleData, childConfig: LocaleData): LocaleData;
+export declare function getSetGlobalLocale(key?: string | string[], values?: LocaleData): string;
+export declare function defineLocale(name: string, config?: LocaleData): Locale;
+export declare function updateLocale(name: string, config?: LocaleData): Locale;
+export declare function getLocale(key?: string | string[]): Locale;
+export declare function listLocales(): string[];

package/datepicker/sub-components/chronos/moment/add-subtract.d.ts

@@ -0,0 +1,5 @@
+import { Duration } from '../duration/constructor';
+import { UnitOfTime } from '../types';
+export declare function add(date: Date, val: number, period: UnitOfTime, isUTC?: boolean): Date;
+export declare function subtract(date: Date, val: number, period: UnitOfTime, isUTC?: boolean): Date;
+export declare function addSubtract(date: Date, duration: Duration, isAdding: number, isUTC?: boolean): Date;

package/datepicker/sub-components/chronos/moment/calendar.d.ts

@@ -0,0 +1,15 @@
+import { Locale } from '../locale/locale.class';
+import { DateInput } from '../test/chain';
+import { DateParsingConfig } from '../create/parsing.types';
+export declare type CalendarSpecVal = string | ((m?: DateInput, now?: Date) => string);
+export interface CalendarSpec {
+    sameDay?: CalendarSpecVal;
+    nextDay?: CalendarSpecVal;
+    lastDay?: CalendarSpecVal;
+    nextWeek?: CalendarSpecVal;
+    lastWeek?: CalendarSpecVal;
+    sameElse?: CalendarSpecVal;
+    [x: string]: CalendarSpecVal | void;
+}
+export declare function getCalendarFormat(date: Date, now: Date, config: DateParsingConfig): "sameElse" | "lastWeek" | "lastDay" | "sameDay" | "nextDay" | "nextWeek";
+export declare function calendar(date: Date, time: Date, formats: CalendarSpec, locale?: Locale, config?: DateParsingConfig): string;

package/datepicker/sub-components/chronos/moment/diff.d.ts

@@ -0,0 +1,3 @@
+import { DateParsingConfig } from '../create/parsing.types';
+import { UnitOfTime } from '../types';
+export declare function diff(date: Date, input: Date, units: UnitOfTime, asFloat: boolean, config?: DateParsingConfig): number;

package/datepicker/sub-components/chronos/moment/min-max.d.ts

@@ -0,0 +1,2 @@
+export declare function min(...args: Date[]): Date;
+export declare function max(...args: Date[]): Date;

package/datepicker/sub-components/chronos/parse/regex.d.ts

@@ -0,0 +1,22 @@
+import { Locale } from '../locale/locale.class';
+export declare const match1: RegExp;
+export declare const match2: RegExp;
+export declare const match3: RegExp;
+export declare const match4: RegExp;
+export declare const match6: RegExp;
+export declare const match1to2: RegExp;
+export declare const match3to4: RegExp;
+export declare const match5to6: RegExp;
+export declare const match1to3: RegExp;
+export declare const match1to4: RegExp;
+export declare const match1to6: RegExp;
+export declare const matchUnsigned: RegExp;
+export declare const matchSigned: RegExp;
+export declare const matchOffset: RegExp;
+export declare const matchShortOffset: RegExp;
+export declare const matchTimestamp: RegExp;
+export declare const matchWord: RegExp;
+export declare type RegExpTokenFn = (isStrict: boolean, locale: Locale) => RegExp;
+export declare function addRegexToken(token: string, regex: RegExp | RegExpTokenFn, strictRegex?: RegExp): void;
+export declare function getParseRegexForToken(token: string, locale: Locale): RegExp;
+export declare function regexEscape(str: string): string;

package/datepicker/sub-components/chronos/parse/token.d.ts

@@ -0,0 +1,5 @@
+import { DateParsingConfig } from '../create/parsing.types';
+import { DateParseTokenFn } from '../types';
+export declare function addParseToken(token: string | string[], callback: DateParseTokenFn | number): void;
+export declare function addWeekParseToken(token: string[], callback: DateParseTokenFn): void;
+export declare function addTimeToArrayFromToken(token: string, input: string, config: DateParsingConfig): DateParsingConfig;

package/datepicker/sub-components/chronos/public_api.d.ts

@@ -0,0 +1,57 @@
+import './units/index';
+export { add, subtract } from './moment/add-subtract';
+export { getDay, isFirstDayOfWeek, isSameYear, isSameDay, isSameMonth, getFullYear, getFirstDayOfMonth, getMonth } from './utils/date-getters';
+export { parseDate } from './create/local';
+export { utcAsLocal } from './create/local';
+export { formatDate } from './format';
+export { listLocales, getLocale, updateLocale, defineLocale, getSetGlobalLocale } from './locale/locales';
+export { LocaleData } from './locale/locale.class';
+export { isAfter, isBefore, isDisabledDay, isSame } from './utils/date-compare';
+export { isArray, isDateValid, isDate } from './utils/type-checks';
+export { shiftDate, setFullDate } from './utils/date-setters';
+export { endOf, startOf } from './utils/start-end-of';
+export { TimeUnit } from './types';
+export { arLocale } from './i18n/ar';
+export { bgLocale } from './i18n/bg';
+export { caLocale } from './i18n/ca';
+export { csLocale } from './i18n/cs';
+export { daLocale } from './i18n/da';
+export { deLocale } from './i18n/de';
+export { enGbLocale } from './i18n/en-gb';
+export { esDoLocale } from './i18n/es-do';
+export { esLocale } from './i18n/es';
+export { esUsLocale } from './i18n/es-us';
+export { etLocale } from './i18n/et';
+export { fiLocale } from './i18n/fi';
+export { frLocale } from './i18n/fr';
+export { glLocale } from './i18n/gl';
+export { heLocale } from './i18n/he';
+export { hiLocale } from './i18n/hi';
+export { huLocale } from './i18n/hu';
+export { hrLocale } from './i18n/hr';
+export { idLocale } from './i18n/id';
+export { itLocale } from './i18n/it';
+export { jaLocale } from './i18n/ja';
+export { kaLocale } from './i18n/ka';
+export { kkLocale } from './i18n/kk';
+export { koLocale } from './i18n/ko';
+export { ltLocale } from './i18n/lt';
+export { lvLocale } from './i18n/lv';
+export { mnLocale } from './i18n/mn';
+export { nbLocale } from './i18n/nb';
+export { nlBeLocale } from './i18n/nl-be';
+export { nlLocale } from './i18n/nl';
+export { plLocale } from './i18n/pl';
+export { ptBrLocale } from './i18n/pt-br';
+export { roLocale } from './i18n/ro';
+export { ruLocale } from './i18n/ru';
+export { skLocale } from './i18n/sk';
+export { slLocale } from './i18n/sl';
+export { sqLocale } from './i18n/sq';
+export { svLocale } from './i18n/sv';
+export { thLocale } from './i18n/th';
+export { thBeLocale } from './i18n/th-be';
+export { trLocale } from './i18n/tr';
+export { ukLocale } from './i18n/uk';
+export { viLocale } from './i18n/vi';
+export { zhCnLocale } from './i18n/zh-cn';

package/datepicker/sub-components/chronos/test/chain.d.ts

@@ -0,0 +1,214 @@
+import { DateArray, UnitOfTime } from '../types';
+import { Locale, LocaleData } from '../locale/locale.class';
+import { DateParsingConfig } from '../create/parsing.types';
+import { CalendarSpec } from '../moment/calendar';
+import { Duration } from '../duration/constructor';
+export declare type DateInput = string | number | Date | string[] | DateArray | MomentInputObject;
+export declare const moment: MomentFn;
+export interface MomentFn {
+    (input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean, isUTC?: boolean): Khronos;
+    ISO_8601: string;
+    RFC_2822: string;
+    utc(input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean): Khronos;
+    parseZone(input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean): Khronos;
+    unix(num: number): Khronos;
+    locale(key?: string | string[], values?: LocaleData): string;
+    duration(inp?: Duration | DateInput | Khronos, unit?: MomentUnitOfTime): Duration;
+    defineLocale(name: string, config?: LocaleData): Locale;
+    parseTwoDigitYear(input: string): number;
+    isDate(input?: any): input is Date;
+    months(): string[];
+    months(index: number): string;
+    months(format: string): string[];
+    months(format: string, index: number): string;
+    monthsShort(): string[];
+    monthsShort(index: number): string;
+    monthsShort(format: string): string[];
+    monthsShort(format: string, index: number): string;
+    weekdays(): string[];
+    weekdays(index: number): string;
+    weekdays(format: string): string[];
+    weekdays(format: string, index: number): string;
+    weekdays(localeSorted: boolean): string[];
+    weekdays(localeSorted: boolean, index: number): string;
+    weekdays(localeSorted: boolean, format: string): string[];
+    weekdays(localeSorted: boolean, format: string, index: number): string;
+    weekdaysShort(): string[];
+    weekdaysShort(index: number): string;
+    weekdaysShort(format: string): string[];
+    weekdaysShort(format: string, index: number): string;
+    weekdaysShort(localeSorted: boolean): string[];
+    weekdaysShort(localeSorted: boolean, index: number): string;
+    weekdaysShort(localeSorted: boolean, format: string): string[];
+    weekdaysShort(localeSorted: boolean, format: string, index: number): string;
+    weekdaysMin(): string[];
+    weekdaysMin(index: number): string;
+    weekdaysMin(format: string): string[];
+    weekdaysMin(format: string, index: number): string;
+    weekdaysMin(localeSorted: boolean): string[];
+    weekdaysMin(localeSorted: boolean, index: number): string;
+    weekdaysMin(localeSorted: boolean, format: string): string[];
+    weekdaysMin(localeSorted: boolean, format: string, index: number): string;
+    relativeTimeThreshold(threshold: string): number | boolean;
+    relativeTimeThreshold(threshold: string, limit: number): boolean;
+    min(...dates: ((DateInput | Khronos)[] | (DateInput | Khronos))[]): Khronos;
+    max(...dates: ((DateInput | Khronos)[] | (DateInput | Khronos))[]): Khronos;
+    localeData(key?: string | string[] | Khronos): Locale;
+    updateLocale(language: string, localeSpec?: LocaleData): Locale;
+    calendarFormat(m: Date, now: Date): string;
+    calendarFormat(m: Khronos, now: Khronos): string;
+    invalid(): Khronos;
+    locales(): string[];
+    updateOffset(m: Khronos, keepTime?: boolean): void;
+}
+export interface MomentInputObject {
+    years?: number;
+    year?: number;
+    y?: number;
+    months?: number;
+    month?: number;
+    M?: number;
+    days?: number;
+    day?: number;
+    d?: number;
+    dates?: number;
+    date?: number;
+    D?: number;
+    hours?: number;
+    hour?: number;
+    h?: number;
+    minutes?: number;
+    minute?: number;
+    m?: number;
+    seconds?: number;
+    second?: number;
+    s?: number;
+    milliseconds?: number;
+    millisecond?: number;
+    ms?: number;
+    w?: number;
+    week?: number;
+    weeks?: number;
+    Q?: number;
+    quarter?: number;
+    quarters?: number;
+    weekYear?: number;
+}
+export declare type MomentUnitOfTime = ('year' | 'years' | 'y' | 'month' | 'months' | 'M' | 'week' | 'weeks' | 'w' | 'day' | 'days' | 'd' | 'hour' | 'hours' | 'h' | 'minute' | 'minutes' | 'm' | 'second' | 'seconds' | 's' | 'millisecond' | 'milliseconds' | 'ms' | 'q' | 'quarter' | 'quarters' | 'Q' | 'isoWeek' | 'isoWeeks' | 'W' | 'date' | 'dates' | 'D');
+export declare type MomentAll = MomentUnitOfTime | 'weekYear' | 'weekYears' | 'gg' | 'isoWeekYear' | 'isoWeekYears' | 'GG' | 'dayOfYear' | 'dayOfYears' | 'DDD' | 'weekday' | 'weekdays' | 'e' | 'isoWeekday' | 'isoWeekdays' | 'E';
+export declare class Khronos {
+    _date: Date;
+    _isUTC: boolean;
+    _isStrict: boolean;
+    _locale: Locale;
+    _format: string | string[];
+    _offset: number;
+    _tzm: number;
+    constructor(input?: DateInput, format?: string | string[], localeKey?: string, strict?: boolean, isUTC?: boolean, offset?: number);
+    _toConfig(): DateParsingConfig;
+    locale(): string;
+    locale(localeKey: string | string[] | Khronos): Khronos;
+    localeData(): Locale;
+    add(val: number | string | MomentInputObject, period?: UnitOfTime | MomentUnitOfTime): Khronos;
+    calendar(time?: DateInput | Khronos, formats?: CalendarSpec): string;
+    clone(): Khronos;
+    diff(b: DateInput | Khronos, unitOfTime?: MomentUnitOfTime, precise?: boolean): number;
+    endOf(period?: MomentUnitOfTime): Khronos;
+    format(format?: string): string;
+    from(time?: DateInput | Khronos, withoutSuffix?: boolean): string;
+    fromNow(withoutSuffix?: boolean): string;
+    to(inp: DateInput | Khronos, suffix?: boolean): string;
+    toNow(withoutPrefix?: boolean): string;
+    subtract(val: number | string | MomentInputObject, period?: UnitOfTime | MomentUnitOfTime): Khronos;
+    get(period: MomentAll): number;
+    set(period: MomentAll | MomentInputObject, input?: number): Khronos;
+    toString(): string;
+    toISOString(): string;
+    inspect(): string;
+    toJSON(): string;
+    toDate(): Date;
+    toObject(): {
+        [key in MomentUnitOfTime]?: number;
+    };
+    toArray(): DateArray;
+    isAfter(date: Khronos, unit?: MomentUnitOfTime): boolean;
+    isBefore(date: Khronos, unit?: MomentUnitOfTime): boolean;
+    isBetween(from: Khronos, to: Khronos, unit?: MomentUnitOfTime, inclusivity?: string): boolean;
+    isSame(date: Khronos, unit?: MomentUnitOfTime): boolean;
+    isSameOrAfter(date: Khronos, unit?: MomentUnitOfTime): boolean;
+    isSameOrBefore(date: Khronos, unit?: MomentUnitOfTime): boolean;
+    isValid(): boolean;
+    valueOf(): number;
+    unix(): number;
+    utcOffset(): number;
+    utcOffset(b: number | string, keepLocalTime?: boolean): Khronos;
+    utc(keepLocalTime?: boolean): Khronos;
+    local(keepLocalTime?: boolean): Khronos;
+    parseZone(input?: string): Khronos;
+    hasAlignedHourOffset(input?: Khronos): boolean;
+    isDST(): boolean;
+    isLocal(): boolean;
+    isUtcOffset(): boolean;
+    isUTC(): boolean;
+    isUtc(): boolean;
+    zoneAbbr(): string;
+    zoneName(): string;
+    year(): number;
+    year(year: number): Khronos;
+    weekYear(): number;
+    weekYear(val: number): Khronos;
+    isoWeekYear(): number;
+    isoWeekYear(val: number): Khronos;
+    isLeapYear(): boolean;
+    month(): number;
+    month(month: number | string): Khronos;
+    /** @deprecated */
+    hour(): number;
+    hour(hours: number): Khronos;
+    hours(): number;
+    hours(hours: number): Khronos;
+    /** @deprecated */
+    minute(): number;
+    minute(minutes: number): Khronos;
+    minutes(): number;
+    minutes(minutes: number): Khronos;
+    /** @deprecated */
+    second(): number;
+    second(seconds: number): Khronos;
+    seconds(): number;
+    seconds(seconds: number): Khronos;
+    /** @deprecated */
+    millisecond(): number;
+    millisecond(ms: number): Khronos;
+    milliseconds(): number;
+    milliseconds(seconds: number): Khronos;
+    date(): number;
+    date(date: number): Khronos;
+    day(): number;
+    day(input: number | string): Khronos;
+    weekday(): number;
+    weekday(val: number): Khronos;
+    isoWeekday(): number;
+    isoWeekday(val: number | string): Khronos;
+    dayOfYear(): number;
+    dayOfYear(val: number): Khronos;
+    week(): number;
+    week(input: number): Khronos;
+    /** @deprecated */
+    weeks(): number;
+    weeks(input: number): Khronos;
+    isoWeek(): number;
+    isoWeek(val: number): Khronos;
+    /** @deprecated */
+    isoWeeks(): number;
+    isoWeeks(val: number): Khronos;
+    weeksInYear(): number;
+    isoWeeksInYear(): number;
+    daysInMonth(): number;
+    quarter(): number;
+    quarter(val: number): Khronos;
+    /** @deprecated */
+    quarters(): number;
+    quarters(val: number): Khronos;
+    startOf(period?: MomentUnitOfTime): Khronos;
+}

package/datepicker/sub-components/chronos/types.d.ts

@@ -0,0 +1,36 @@
+import { Locale } from './locale/locale.class';
+import { DateParsingConfig } from './create/parsing.types';
+export declare type UnitOfTime = 'year' | 'month' | 'day' | 'date' | 'dayOfYear' | 'hours' | 'minutes' | 'seconds' | 'milliseconds' | 'quarter' | 'week' | 'isoWeek' | 'weekYear' | 'isoWeekYear' | 'weekday' | 'isoWeekday';
+export interface TimeUnit {
+    year?: number;
+    month?: number;
+    day?: number;
+    hour?: number;
+    minute?: number;
+    seconds?: number;
+    milliseconds?: number;
+}
+export interface DateFormatterOptions {
+    format: string;
+    locale: Locale;
+    isUTC: boolean;
+    offset: number;
+}
+export declare type DateFormatterFn = (date: Date, opts: DateFormatterOptions) => string;
+export interface DateObject {
+    year?: number;
+    month?: number;
+    day?: number;
+    hours?: number;
+    minutes?: number;
+    seconds?: number;
+    milliseconds?: number;
+    week?: number;
+    quarter?: number;
+}
+export declare type DateArray = number[];
+export interface WeekParsing {
+    [key: string]: number;
+    [key: number]: number;
+}
+export declare type DateParseTokenFn = (input: string, array: DateArray | WeekParsing, config: DateParsingConfig, token?: string) => DateParsingConfig;

package/datepicker/sub-components/chronos/units/aliases.d.ts

@@ -0,0 +1,7 @@
+import { DateObject, UnitOfTime } from '../types';
+export declare type ExtendedUnitOfTime = UnitOfTime | 'date' | 'week' | 'isoWeek' | 'dayOfYear' | 'weekday' | 'isoWeekday' | 'second' | 'millisecond' | 'minute' | 'hour' | 'quarter' | 'weekYear' | 'isoWeekYear';
+export declare function addUnitAlias(unit: ExtendedUnitOfTime, shorthand: string): void;
+export declare function normalizeUnits(units: string | string[]): string;
+export declare function normalizeObjectUnits(inputObject: {
+    [key: string]: number;
+}): DateObject;

package/datepicker/sub-components/chronos/units/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const YEAR = 0;
+export declare const MONTH = 1;
+export declare const DATE = 2;
+export declare const HOUR = 3;
+export declare const MINUTE = 4;
+export declare const SECOND = 5;
+export declare const MILLISECOND = 6;
+export declare const WEEK = 7;
+export declare const WEEKDAY = 8;

package/datepicker/sub-components/chronos/units/day-of-month.d.ts

@@ -0,0 +1 @@
+export declare function initDayOfMonth(): void;

package/datepicker/sub-components/chronos/units/day-of-week.d.ts

@@ -0,0 +1,20 @@
+import { Locale } from '../locale/locale.class';
+export declare function initDayOfWeek(): void;
+export declare function parseWeekday(input: string | number, locale: Locale): number;
+export declare function parseIsoWeekday(input: string | number, locale?: Locale): number;
+export declare function getSetDayOfWeek(date: Date, input: number, opts: {
+    isUTC?: boolean;
+    locale: Locale;
+}): Date | number;
+export declare function setDayOfWeek(date: Date, input: number, locale?: Locale, isUTC?: boolean): Date;
+export declare function getDayOfWeek(date: Date, isUTC?: boolean): number;
+/********************************************/
+export declare function getLocaleDayOfWeek(date: Date, locale?: Locale, isUTC?: boolean): number;
+export declare function setLocaleDayOfWeek(date: Date, input: number, opts?: {
+    locale?: Locale;
+    isUTC?: boolean;
+}): Date;
+export declare function getISODayOfWeek(date: Date, isUTC?: boolean): number;
+export declare function setISODayOfWeek(date: Date, input: number | string, opts?: {
+    locale?: Locale;
+}): Date;

package/datepicker/sub-components/chronos/units/day-of-year.d.ts

@@ -0,0 +1,3 @@
+export declare function initDayOfYear(): void;
+export declare function getDayOfYear(date: Date, isUTC?: boolean): number;
+export declare function setDayOfYear(date: Date, input: number): Date;

package/datepicker/sub-components/chronos/units/hour.d.ts

@@ -0,0 +1 @@
+export declare function initHour(): void;

package/datepicker/sub-components/chronos/units/index.d.ts

@@ -0,0 +1,18 @@
+import './aliases';
+import './constants';
+import './day-of-month';
+import './day-of-week';
+import './day-of-year';
+import './hour';
+import './millisecond';
+import './minute';
+import './month';
+import './offset';
+import './priorities';
+import './quarter';
+import './second';
+import './timestamp';
+import './week';
+import './week-calendar-utils';
+import './week-year';
+import './year';

package/datepicker/sub-components/chronos/units/millisecond.d.ts

@@ -0,0 +1 @@
+export declare function initMillisecond(): void;

package/datepicker/sub-components/chronos/units/minute.d.ts

@@ -0,0 +1 @@
+export declare function initMinute(): void;

package/datepicker/sub-components/chronos/units/month.d.ts

@@ -0,0 +1,2 @@
+export declare function daysInMonth(year: number, month: number): number;
+export declare function initMonth(): void;

package/datepicker/sub-components/chronos/units/offset.d.ts

@@ -0,0 +1,10 @@
+import { DateParsingConfig } from '../create/parsing.types';
+export declare function initOffset(): void;
+export declare function cloneWithOffset(input: Date, date: Date, config?: DateParsingConfig): Date;
+export declare function getDateOffset(date: Date): number;
+export declare function getUTCOffset(date: Date, config?: DateParsingConfig): number;
+export declare function setUTCOffset(date: Date, input: number | string, keepLocalTime?: boolean, keepMinutes?: boolean, config?: DateParsingConfig): Date;
+export declare function setOffsetToUTC(date: Date, keepLocalTime?: boolean): Date;
+export declare function isDaylightSavingTime(date: Date): boolean;
+export declare function setOffsetToParsedOffset(date: Date, input: string, config?: DateParsingConfig): Date;
+export declare function hasAlignedHourOffset(date: Date, input?: Date): boolean;

package/datepicker/sub-components/chronos/units/priorities.d.ts

@@ -0,0 +1 @@
+export declare function addUnitPriority(unit: string, priority: number): void;

package/datepicker/sub-components/chronos/units/quarter.d.ts

@@ -0,0 +1,3 @@
+export declare function initQuarter(): void;
+export declare function getQuarter(date: Date, isUTC?: boolean): number;
+export declare function setQuarter(date: Date, quarter: number, isUTC?: boolean): Date;

package/datepicker/sub-components/chronos/units/second.d.ts

@@ -0,0 +1 @@
+export declare function initSecond(): void;

package/datepicker/sub-components/chronos/units/timestamp.d.ts

@@ -0,0 +1 @@
+export declare function initTimestamp(): void;

package/datepicker/sub-components/chronos/units/timezone.d.ts

@@ -0,0 +1,3 @@
+export declare function initTimezone(): void;
+export declare function getZoneAbbr(isUTC: boolean): "" | "UTC";
+export declare function getZoneName(isUTC: boolean): "" | "Coordinated Universal Time";