@mis-wis/common 0.1.5 → 0.1.7

package/src/lib/components/datepicker/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/src/lib/components/datepicker/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/src/lib/components/datepicker/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/src/lib/components/datepicker/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/src/lib/components/datepicker/chronos/units/day-of-month.d.ts

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

package/src/lib/components/datepicker/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/src/lib/components/datepicker/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/src/lib/components/datepicker/chronos/units/hour.d.ts

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

package/src/lib/components/datepicker/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/src/lib/components/datepicker/chronos/units/millisecond.d.ts

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

package/src/lib/components/datepicker/chronos/units/minute.d.ts

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

package/src/lib/components/datepicker/chronos/units/month.d.ts

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

package/src/lib/components/datepicker/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/src/lib/components/datepicker/chronos/units/priorities.d.ts

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

package/src/lib/components/datepicker/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/src/lib/components/datepicker/chronos/units/second.d.ts

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

package/src/lib/components/datepicker/chronos/units/timestamp.d.ts

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

package/src/lib/components/datepicker/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";

package/src/lib/components/datepicker/chronos/units/week-calendar-utils.d.ts

@@ -0,0 +1,9 @@
+export declare function dayOfYearFromWeeks(year: number, week: number, weekday: number, dow: number, doy: number): {
+    year: number;
+    dayOfYear: number;
+};
+export declare function weekOfYear(date: Date, dow: number, doy: number, isUTC?: boolean): {
+    week: number;
+    year: number;
+};
+export declare function weeksInYear(year: number, dow: number, doy: number): number;

package/src/lib/components/datepicker/chronos/units/week-year.d.ts

@@ -0,0 +1,8 @@
+import { Locale } from '../locale/locale.class';
+export declare function initWeekYear(): void;
+export declare function getSetWeekYear(date: Date, input: number, locale?: Locale, isUTC?: boolean): number | Date;
+export declare function getWeekYear(date: Date, locale?: Locale, isUTC?: boolean): number;
+export declare function getSetISOWeekYear(date: Date, input: number, isUTC?: boolean): number | Date;
+export declare function getISOWeekYear(date: Date, isUTC?: boolean): number;
+export declare function getISOWeeksInYear(date: Date, isUTC?: boolean): number;
+export declare function getWeeksInYear(date: Date, isUTC?: boolean, locale?: Locale): number;

package/src/lib/components/datepicker/chronos/units/week.d.ts

@@ -0,0 +1,6 @@
+import { Locale } from '../locale/locale.class';
+export declare function initWeek(): void;
+export declare function setWeek(date: Date, input: number, locale?: Locale): Date;
+export declare function getWeek(date: Date, locale?: Locale, isUTC?: boolean): number;
+export declare function setISOWeek(date: Date, input: number): Date;
+export declare function getISOWeek(date: Date, isUTC?: boolean): number;

package/src/lib/components/datepicker/chronos/units/year.d.ts

@@ -0,0 +1,4 @@
+export declare function initYear(): void;
+export declare function parseTwoDigitYear(input: string): number;
+export declare function daysInYear(year: number): number;
+export declare function isLeapYear(year: number): boolean;

package/src/lib/components/datepicker/chronos/utils/abs-ceil.d.ts

@@ -0,0 +1 @@
+export declare function absCeil(number: number): number;

package/src/lib/components/datepicker/chronos/utils/abs-round.d.ts

@@ -0,0 +1 @@
+export declare function absRound(num: number): number;

package/src/lib/components/datepicker/chronos/utils/compare-arrays.d.ts

@@ -0,0 +1 @@
+export declare function compareArrays<T>(array1: T[], array2: T[], dontConvert: boolean): number;

package/src/lib/components/datepicker/chronos/utils/date-compare.d.ts

@@ -0,0 +1,9 @@
+import { UnitOfTime } from '../types';
+export declare function isAfter(date1: Date, date2: Date, units?: UnitOfTime): boolean;
+export declare function isBefore(date1: Date, date2: Date, units?: UnitOfTime): boolean;
+export declare function isDisabledDay(date: Date, daysDisabled: number[]): boolean;
+export declare function isBetween(date: Date, from: Date, to: Date, units: UnitOfTime, inclusivity?: string): boolean;
+export declare function isSame(date1: Date, date2: Date, units?: UnitOfTime): boolean;
+export declare function isSameDay(date1: Date, date2: Date): boolean;
+export declare function isSameOrAfter(date1: Date, date2: Date, units?: UnitOfTime): boolean;
+export declare function isSameOrBefore(date1: Date, date2: Date, units?: UnitOfTime): boolean;

package/src/lib/components/datepicker/chronos/utils/date-getters.d.ts

@@ -0,0 +1,18 @@
+export declare function getHours(date: Date, isUTC?: boolean): number;
+export declare function getMinutes(date: Date, isUTC?: boolean): number;
+export declare function getSeconds(date: Date, isUTC?: boolean): number;
+export declare function getMilliseconds(date: Date, isUTC?: boolean): number;
+export declare function getTime(date: Date): number;
+export declare function getDay(date: Date, isUTC?: boolean): number;
+export declare function getDate(date: Date, isUTC?: boolean): number;
+export declare function getMonth(date: Date, isUTC?: boolean): number;
+export declare function getFullYear(date: Date, isUTC?: boolean): number;
+export declare function getUnixTime(date: Date): number;
+export declare function unix(date: Date): number;
+export declare function getFirstDayOfMonth(date: Date): Date;
+export declare function daysInMonth(date: Date): number;
+export declare function _daysInMonth(year: number, month: number): number;
+export declare function isFirstDayOfWeek(date: Date, firstDayOfWeek: number): boolean;
+export declare function isSameMonth(date1: Date, date2: Date): boolean;
+export declare function isSameYear(date1: Date, date2: Date): boolean;
+export declare function isSameDay(date1: Date, date2: Date): boolean;

package/src/lib/components/datepicker/chronos/utils/date-setters.d.ts

@@ -0,0 +1,12 @@
+import { TimeUnit } from '../types';
+export declare function shiftDate(date: Date, unit: TimeUnit): Date;
+export declare function setFullDate(date: Date, unit: TimeUnit): Date;
+export declare function setFullYear(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setMonth(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setDay(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setHours(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setMinutes(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setSeconds(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setMilliseconds(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setDate(date: Date, value: number, isUTC?: boolean): Date;
+export declare function setTime(date: Date, value: number): Date;

package/src/lib/components/datepicker/chronos/utils/defaults.d.ts

@@ -0,0 +1 @@
+export declare function defaults<T>(a?: T, b?: T, c?: T): T;

package/src/lib/components/datepicker/chronos/utils/start-end-of.d.ts

@@ -0,0 +1,3 @@
+import { UnitOfTime } from '../types';
+export declare function startOf(date: Date, unit: UnitOfTime, isUTC?: boolean): Date;
+export declare function endOf(date: Date, unit: UnitOfTime, isUTC?: boolean): Date;

package/src/lib/components/datepicker/chronos/utils/type-checks.d.ts

@@ -0,0 +1,12 @@
+export declare function isString(str: any): str is string;
+export declare function isDate(value: any): value is Date;
+export declare function isBoolean(value: any): value is boolean;
+export declare function isDateValid(date: Date): boolean;
+export declare function isFunction(fn: any): fn is Function;
+export declare function isNumber(value?: any): value is number;
+export declare function isArray<T>(input?: any): input is T[];
+export declare function hasOwnProp<T>(a: T, b: string): b is Extract<keyof T, string>;
+export declare function isObject<T>(input: any): input is T;
+export declare function isObjectEmpty(obj: any): boolean;
+export declare function isUndefined(input: any): boolean;
+export declare function toInt<T>(argumentForCoercion: string | number | T): number;

package/src/lib/components/datepicker/chronos/utils/zero-fill.d.ts

@@ -0,0 +1 @@
+export declare function zeroFill(num: number, targetLength: number, forceSign?: boolean): string;

package/src/lib/components/datepicker/chronos/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function mod(n: number, x: number): number;
+export declare function absFloor(num: number): number;

package/src/lib/components/datepicker/component-loader/bs-component-ref.class.d.ts

@@ -0,0 +1,5 @@
+import { TemplateRef, ViewContainerRef } from '@angular/core';
+export declare class BsComponentRef<T> {
+    templateRef: TemplateRef<T>;
+    viewContainer: ViewContainerRef;
+}

package/src/lib/components/datepicker/component-loader/component-loader.class.d.ts

@@ -0,0 +1,75 @@
+import { ApplicationRef, ComponentFactoryResolver, ComponentRef, ElementRef, EmbeddedViewRef, EventEmitter, Injector, NgZone, Renderer2, StaticProvider, TemplateRef, Type, ViewContainerRef } from '@angular/core';
+import { PositioningOptions, PositioningService } from '../positioning';
+import { ListenOptions } from './listen-options.model';
+export declare class ComponentLoader<T> {
+    private _viewContainerRef;
+    private _renderer;
+    private _elementRef;
+    private _injector;
+    private _componentFactoryResolver;
+    private _ngZone;
+    private _applicationRef;
+    private _posService;
+    onBeforeShow: EventEmitter<void>;
+    onShown: EventEmitter<any>;
+    onBeforeHide: EventEmitter<any>;
+    onHidden: EventEmitter<any>;
+    instance: T;
+    _componentRef: ComponentRef<T>;
+    _inlineViewRef: EmbeddedViewRef<T>;
+    private _providers;
+    private _componentFactory;
+    private _zoneSubscription;
+    private _contentRef;
+    private _innerComponent;
+    private _unregisterListenersFn;
+    get isShown(): boolean;
+    private _isHiding;
+    /**
+     * Placement of a component. Accepts: "top", "bottom", "left", "right"
+     */
+    private attachment;
+    /**
+     * A selector specifying the element the popover should be appended to.
+     */
+    private container;
+    /**
+     * A selector used if container element was not found
+     */
+    private containerDefaultSelector;
+    /**
+     * Specifies events that should trigger. Supports a space separated list of
+     * event names.
+     */
+    private triggers;
+    private _listenOpts;
+    private _globalListener;
+    /**
+     * Do not use this directly, it should be instanced via
+     * `ComponentLoadFactory.attach`
+     * @internal
+     */
+    constructor(_viewContainerRef: ViewContainerRef, _renderer: Renderer2, _elementRef: ElementRef, _injector: Injector, _componentFactoryResolver: ComponentFactoryResolver, _ngZone: NgZone, _applicationRef: ApplicationRef, _posService: PositioningService);
+    attach(compType: Type<T>): ComponentLoader<T>;
+    to(container?: string | ElementRef): ComponentLoader<T>;
+    position(opts?: PositioningOptions): ComponentLoader<T>;
+    provide(provider: StaticProvider): ComponentLoader<T>;
+    show(opts?: {
+        content?: string | TemplateRef<any>;
+        context?: any;
+        initialState?: any;
+        [key: string]: any;
+        id?: number | string;
+    }): ComponentRef<T>;
+    hide(id?: number | string): ComponentLoader<T>;
+    toggle(): void;
+    dispose(): void;
+    listen(listenOpts: ListenOptions): ComponentLoader<T>;
+    _removeGlobalListener(): void;
+    attachInline(vRef: ViewContainerRef, template: TemplateRef<any>): ComponentLoader<T>;
+    _registerOutsideClick(): void;
+    getInnerComponent(): ComponentRef<T>;
+    private _subscribePositioning;
+    private _unsubscribePositioning;
+    private _getContentRef;
+}

package/src/lib/components/datepicker/component-loader/component-loader.factory.d.ts

@@ -0,0 +1,21 @@
+import { ApplicationRef, ComponentFactoryResolver, ElementRef, Injector, NgZone, Renderer2, ViewContainerRef } from '@angular/core';
+import { ComponentLoader } from './component-loader.class';
+import { PositioningService } from '../positioning';
+import * as i0 from "@angular/core";
+export declare class ComponentLoaderFactory {
+    private _componentFactoryResolver;
+    private _ngZone;
+    private _injector;
+    private _posService;
+    private _applicationRef;
+    constructor(_componentFactoryResolver: ComponentFactoryResolver, _ngZone: NgZone, _injector: Injector, _posService: PositioningService, _applicationRef: ApplicationRef);
+    /**
+     *
+     * @param _elementRef
+     * @param _viewContainerRef
+     * @param _renderer
+     */
+    createLoader<T>(_elementRef: ElementRef, _viewContainerRef: ViewContainerRef, _renderer: Renderer2): ComponentLoader<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentLoaderFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentLoaderFactory>;
+}

package/src/lib/components/datepicker/component-loader/content-ref.class.d.ts

@@ -0,0 +1,7 @@
+import { ComponentRef, ViewRef } from '@angular/core';
+export declare class ContentRef {
+    nodes: any[];
+    viewRef?: ViewRef;
+    componentRef?: ComponentRef<any>;
+    constructor(nodes: any[], viewRef?: ViewRef, componentRef?: ComponentRef<any>);
+}

package/src/lib/components/datepicker/component-loader/index.d.ts

@@ -0,0 +1 @@
+export * from './public_api';

package/src/lib/components/datepicker/component-loader/listen-options.model.d.ts

@@ -0,0 +1,11 @@
+export declare type BsEventCallback = (event?: any) => boolean | void;
+export interface ListenOptions {
+    target?: HTMLElement;
+    targets?: HTMLElement[];
+    triggers?: string;
+    outsideClick?: boolean;
+    outsideEsc?: boolean;
+    show?: BsEventCallback;
+    hide?: BsEventCallback;
+    toggle?: BsEventCallback;
+}

package/src/lib/components/datepicker/component-loader/public_api.d.ts

@@ -0,0 +1,4 @@
+export { BsComponentRef } from './bs-component-ref.class';
+export { ComponentLoader } from './component-loader.class';
+export { ComponentLoaderFactory } from './component-loader.factory';
+export { ContentRef } from './content-ref.class';

package/src/lib/components/datepicker/date-formatter.d.ts

@@ -0,0 +1,3 @@
+export declare class DateFormatter {
+    format(date: Date, format: string, locale: string): string;
+}

package/src/lib/components/datepicker/datepicker-animations.d.ts

@@ -0,0 +1,3 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+export declare const DATEPICKER_ANIMATION_TIMING = "220ms cubic-bezier(0, 0, 0.2, 1)";
+export declare const datepickerAnimation: AnimationTriggerMetadata;