nxt-pick-datetime 20.0.0 → 21.0.0

package/types/nxt-pick-datetime.d.ts

@@ -0,0 +1,1200 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, OutputEmitterRef, OnInit, OnDestroy, AfterContentInit, ElementRef } from '@angular/core';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import * as nxt_pick_datetime from 'nxt-pick-datetime';
+import { ScrollStrategy } from '@angular/cdk/overlay';
+
+declare abstract class DateTimeAdapter<T> {
+    /** The locale to use for all dates */
+    protected readonly locale: _angular_core.WritableSignal<any>;
+    /** total milliseconds in a day */
+    protected readonly millisecondsInDay = 86400000;
+    /** total milliseconds in a minute */
+    protected readonly milliseondsInMinute = 60000;
+    /**
+     * Get the year of the given date
+     */
+    abstract getYear(date?: T): number;
+    /**
+     * Get the month of the given date
+     * 0 -- January
+     * 11 -- December
+     * */
+    abstract getMonth(date?: T): number;
+    /**
+     * Get the day of the week of the given date
+     * 0 -- Sunday
+     * 6 -- Saturday
+     * */
+    abstract getDay(date?: T): number;
+    /**
+     * Get the day num of the given date
+     */
+    abstract getDate(date?: T): number;
+    /**
+     * Get the hours of the given date
+     */
+    abstract getHours(date?: T): number;
+    /**
+     * Get the minutes of the given date
+     */
+    abstract getMinutes(date?: T): number;
+    /**
+     * Get the seconds of the given date
+     */
+    abstract getSeconds(date?: T): number;
+    /**
+     * Get the milliseconds timestamp of the given date
+     */
+    abstract getTime(date?: T): number;
+    /**
+     * Gets the number of days in the month of the given date.
+     */
+    abstract getNumDaysInMonth(date?: T): number;
+    /**
+     * Get the number of calendar days between the given dates.
+     * If dateLeft is before dateRight, it would return positive value
+     * If dateLeft is after dateRight, it would return negative value
+     */
+    abstract differenceInCalendarDays(dateLeft?: T, dateRight?: T): number | undefined;
+    /**
+     * Gets the name for the year of the given date.
+     */
+    abstract getYearName(date?: T): string;
+    /**
+     * Get a list of month names
+     */
+    abstract getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    /**
+     * Get a list of week names
+     */
+    abstract getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    /**
+     * Gets a list of names for the dates of the month.
+     */
+    abstract getDateNames(): string[];
+    /**
+     * Return a Date object as a string, using the ISO standard
+     */
+    abstract toIso8601(date: T): string;
+    /**
+     * Check if the give dates are equal
+     */
+    abstract isEqual(dateLeft?: T, dateRight?: T): boolean;
+    /**
+     * Check if the give dates are the same day
+     */
+    abstract isSameDay(dateLeft?: T, dateRight?: T): boolean;
+    /**
+     * Checks whether the given date is valid.
+     */
+    abstract isValid(date?: T): boolean;
+    /**
+     * Gets date instance that is not valid.
+     */
+    abstract invalid(): T;
+    /**
+     * Checks whether the given object is considered a date instance by this DateTimeAdapter.
+     */
+    abstract isDateInstance(obj: any): boolean;
+    /**
+     * Add the specified number of years to the given date
+     */
+    abstract addCalendarYears(date: T | undefined, amount: number): T;
+    /**
+     * Add the specified number of months to the given date
+     */
+    abstract addCalendarMonths(date: T | undefined, amount: number): T;
+    /**
+     * Add the specified number of days to the given date
+     */
+    abstract addCalendarDays(date: T | undefined, amount: number): T;
+    /**
+     * Set the hours to the given date.
+     */
+    abstract setHours(date: T | undefined, amount: number): T;
+    /**
+     * Set the minutes to the given date.
+     */
+    abstract setMinutes(date: T | undefined, amount: number): T;
+    /**
+     * Set the seconds to the given date.
+     */
+    abstract setSeconds(date: T | undefined, amount: number): T;
+    /**
+     * Creates a date with the given year, month, date, hour, minute and second. Does not allow over/under-flow of the
+     * month and date.
+     */
+    abstract createDate(year: number, month: number, date: number): T;
+    abstract createDate(year: number, month: number, date: number, hours: number, minutes: number, seconds: number): T;
+    /**
+     * Clone the given date
+     */
+    abstract clone(date?: T): T;
+    /**
+     * Get a new moment
+     * */
+    abstract now(): T;
+    /**
+     * Formats a date as a string according to the given format.
+     */
+    abstract format(date: T | undefined, displayFormat: any): string;
+    /**
+     * Parse a user-provided value to a Date Object
+     */
+    abstract parse(value: any, parseFormat: any): T | undefined;
+    /**
+     * Compare two given dates
+     * 1 if the first date is after the second,
+     * -1 if the first date is before the second
+     * 0 if dates are equal.
+     * */
+    compare(first?: T, second?: T): number;
+    /**
+     * Check if two given dates are in the same year
+     * 1 if the first date's year is after the second,
+     * -1 if the first date's year is before the second
+     * 0 if two given dates are in the same year
+     * */
+    compareYear(first?: T, second?: T): number;
+    /**
+     * Attempts to deserialize a value to a valid date object. This is different from parsing in that
+     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
+     * string). The default implementation does not allow any deserialization, it simply checks that
+     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this
+     * method on all of it's `input` properties that accept dates. It is therefore possible to
+     * support passing values from your backend directly to these properties by overriding this method
+     * to also deserialize the format used by your backend.
+     */
+    deserialize(value: any): T | undefined;
+    /**
+     * Sets the locale used for all dates.
+     */
+    setLocale(locale: any): void;
+    /**
+     * Clamp the given date between min and max dates.
+     */
+    clampDate(date: T, min?: T, max?: T): T;
+}
+
+interface DateTimeFormats {
+    parseInput: any;
+    fullPickerInput: any;
+    datePickerInput: any;
+    timePickerInput: any;
+    monthYearLabel: any;
+    dateA11yLabel: any;
+    monthYearA11yLabel: any;
+}
+/** InjectionToken for date time picker that can be used to override default format */
+declare const NXT_DATE_TIME_FORMATS: InjectionToken<DateTimeFormats>;
+
+type PickerType = 'both' | 'calendar' | 'timer';
+type PickerMode = 'popup' | 'dialog' | 'inline';
+type SelectMode = 'single' | 'range' | 'rangeFrom' | 'rangeTo';
+type RenderItem = 'year' | 'month' | 'date';
+type ViewType = 'month' | 'year' | 'multi-years';
+type DateFilter<T> = (date?: T, forRender?: RenderItem) => boolean;
+declare abstract class DateTimeDirective<T> {
+    protected readonly dateTimeAdapter: DateTimeAdapter<T>;
+    protected readonly dateTimeFormats: DateTimeFormats;
+    /**
+     * When true, shows a timer to configure the seconds value
+     */
+    readonly showSecondsTimer: _angular_core.InputSignal<boolean>;
+    /**
+     * When true, the timer will be in 12-hour format mode
+     */
+    readonly hour12Timer: _angular_core.InputSignal<boolean>;
+    /**
+     * The view that the calendar should start on
+     */
+    readonly startView: _angular_core.InputSignal<ViewType>;
+    /**
+     * Hours to change per step
+     */
+    readonly stepHour: _angular_core.InputSignal<number>;
+    /**
+     * Minutes to change per step
+     */
+    readonly stepMinute: _angular_core.InputSignal<number>;
+    /**
+     * Seconds to change per step
+     */
+    readonly stepSecond: _angular_core.InputSignal<number>;
+    /**
+     * Set the first day of week
+     *
+     * Valid values are from 0 [Sunday] to 6 [Saturday]
+     */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number>;
+    /**
+     * If true, don't show dates from preious / next month on the calendar month view
+     */
+    readonly hideOtherMonths: _angular_core.InputSignal<boolean>;
+    readonly id: string;
+    abstract selected: Signal<T | undefined>;
+    abstract selecteds: Signal<Array<T | undefined>>;
+    abstract dateTimeFilter: Signal<DateFilter<T> | undefined>;
+    abstract max: Signal<T | undefined>;
+    abstract min: Signal<T | undefined>;
+    abstract selectMode: Signal<SelectMode | undefined>;
+    abstract startAt: Signal<T | undefined>;
+    abstract isOpen: Signal<boolean>;
+    abstract pickerMode: Signal<PickerMode>;
+    abstract pickerType: Signal<PickerType>;
+    abstract isInSingleMode: Signal<boolean>;
+    abstract isInRangeMode: Signal<boolean>;
+    abstract disabled: Signal<boolean>;
+    abstract select(date: T | Array<T | undefined>): void;
+    abstract yearSelected: OutputEmitterRef<T>;
+    abstract monthSelected: OutputEmitterRef<T>;
+    abstract selectYear(normalizedYear: T): void;
+    abstract selectMonth(normalizedMonth: T): void;
+    readonly formatString: Signal<any>;
+    /**
+     * Date Time Checker to check if the give dateTime is selectable
+     */
+    readonly dateTimeChecker: _angular_core.WritableSignal<(dateTime: T | undefined) => boolean>;
+    protected getValidDate(obj: any): T | undefined;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DateTimeDirective<any>, never, never, { "showSecondsTimer": { "alias": "showSecondsTimer"; "required": false; "isSignal": true; }; "hour12Timer": { "alias": "hour12Timer"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "stepHour": { "alias": "stepHour"; "required": false; "isSignal": true; }; "stepMinute": { "alias": "stepMinute"; "required": false; "isSignal": true; }; "stepSecond": { "alias": "stepSecond"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "hideOtherMonths": { "alias": "hideOtherMonths"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CalendarCell {
+    value: number;
+    displayValue: string;
+    ariaLabel: string;
+    enabled: boolean;
+    out: boolean;
+    cellClass: string;
+    constructor(value: number, displayValue: string, ariaLabel: string, enabled: boolean, out?: boolean, cellClass?: string);
+}
+
+declare class MonthViewComponent<T> {
+    private readonly dateTimeAdapter;
+    private readonly dateTimeFormats;
+    /**
+     * Whether to hide dates in other months at the start or end of the current month
+     */
+    readonly hideOtherMonths: _angular_core.InputSignal<boolean>;
+    private _firstDayOfWeek;
+    /**
+     * Define the first day of a week
+     * Sunday: 0 ~ Saturday: 6
+     */
+    readonly firstDayOfWeek: _angular_core.InputSignalWithTransform<number, number>;
+    /**
+     * The select mode of the picker;
+     */
+    readonly selectMode: _angular_core.InputSignal<SelectMode>;
+    /** The currently selected date */
+    readonly selected: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    readonly selecteds: _angular_core.InputSignalWithTransform<(T | undefined)[], (T | undefined)[]>;
+    readonly pickerMoment: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /**
+     * A function used to filter which dates are selectable
+     */
+    readonly dateTimeFilter: _angular_core.InputSignal<DateFilter<T> | undefined>;
+    /** The minimum selectable date */
+    readonly min: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The maximum selectable date */
+    readonly max: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    readonly weekdays: _angular_core.Signal<{
+        long: string;
+        short: string;
+        narrow: string;
+    }[]>;
+    readonly _daysData: _angular_core.Signal<{
+        days: CalendarCell[][];
+        todayDate: number | undefined;
+        firstRowOffset: number;
+    } | undefined>;
+    private _days?;
+    readonly days: _angular_core.Signal<CalendarCell[][] | undefined>;
+    readonly activeCell: _angular_core.Signal<number | undefined>;
+    readonly isInSingleMode: _angular_core.Signal<boolean>;
+    readonly isInRangeMode: _angular_core.Signal<boolean>;
+    private firstDateOfMonth;
+    private _todayDate?;
+    /**
+     * The date of the month that today falls on.
+     */
+    readonly todayDate: _angular_core.Signal<number | undefined>;
+    private _selectedDates?;
+    /**
+     * An array to hold all selectedDates' value
+     * the value is the day number in current month
+     */
+    readonly selectedDates: _angular_core.Signal<(number | undefined)[] | undefined>;
+    private _firstRowOffset;
+    readonly firstRowOffset: _angular_core.Signal<number>;
+    /**
+     * Callback to invoke when a new date is selected
+     */
+    readonly selectedChange: _angular_core.OutputEmitterRef<T | undefined>;
+    /**
+     * Callback to invoke when any date is selected.
+     */
+    readonly userSelection: _angular_core.OutputEmitterRef<void>;
+    /** Emits when any date is activated */
+    readonly pickerMomentChange: _angular_core.OutputEmitterRef<T>;
+    /** The body of calendar table */
+    private readonly calendarBodyElm;
+    /**
+     * Handle a calendarCell selected
+     */
+    selectCalendarCell(cell: CalendarCell): void;
+    /**
+     * Handle a new date selected
+     */
+    private selectDate;
+    /**
+     * Handle keydown event on calendar body
+     */
+    handleCalendarKeydown(event: KeyboardEvent): void;
+    /**
+     * Creates CalendarCell for days.
+     */
+    private createDateCell;
+    /**
+     * Check if the date is valid
+     */
+    private isDateEnabled;
+    /**
+     * Get a valid date object
+     */
+    private getValidDate;
+    /**
+     * Check if the give dates are defined and in the same month
+     */
+    isSameMonth(dateLeft?: T, dateRight?: T): boolean;
+    private focusActiveCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MonthViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MonthViewComponent<any>, "nxt-date-time-month-view", never, { "hideOtherMonths": { "alias": "hideOtherMonths"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selecteds": { "alias": "selecteds"; "required": false; "isSignal": true; }; "pickerMoment": { "alias": "pickerMoment"; "required": false; "isSignal": true; }; "dateTimeFilter": { "alias": "dateTimeFilter"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; "userSelection": "userSelection"; "pickerMomentChange": "pickerMomentChange"; }, never, never, true, never>;
+}
+
+declare class MultiYearViewComponent<T> {
+    private readonly pickerIntl;
+    private readonly dateTimeAdapter;
+    /**
+     * The select mode of the picker;
+     */
+    readonly selectMode: _angular_core.InputSignal<SelectMode>;
+    /** The currently selected date */
+    readonly selected: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    readonly selecteds: _angular_core.InputSignalWithTransform<(T | undefined)[], (T | undefined)[]>;
+    /** Settable signal for pickerMoment */
+    readonly _pickerMomentInput: _angular_core.InputSignal<T | undefined>;
+    private readonly _pickerMoment;
+    readonly pickerMoment: _angular_core.Signal<T>;
+    /**
+     * A function used to filter which dates are selectable
+     */
+    readonly dateTimeFilter: _angular_core.InputSignal<DateFilter<T> | undefined>;
+    /** The minimum selectable date */
+    readonly min: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The maximum selectable date */
+    readonly max: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    private readonly yearsData;
+    readonly years: _angular_core.Signal<CalendarCell[][]>;
+    readonly todayYear: _angular_core.Signal<number>;
+    readonly isInSingleMode: _angular_core.Signal<boolean>;
+    readonly isInRangeMode: _angular_core.Signal<boolean>;
+    readonly selectedYears: _angular_core.Signal<(number | undefined)[]>;
+    readonly activeCell: _angular_core.Signal<number | undefined>;
+    readonly tableHeader: _angular_core.Signal<string | undefined>;
+    readonly prevButtonLabel: _angular_core.Signal<string>;
+    readonly nextButtonLabel: _angular_core.Signal<string>;
+    /**
+     * Callback to invoke when a new month is selected
+     */
+    readonly change: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Emits the selected year
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly yearSelected: _angular_core.OutputEmitterRef<T>;
+    /** Emits when any date is activated */
+    readonly pickerMomentChange: _angular_core.OutputEmitterRef<T>;
+    /** Emits when use keyboard enter to select a calendar cell */
+    readonly keyboardEnter: _angular_core.OutputEmitterRef<void>;
+    /** The body of calendar table */
+    private readonly calendarBodyElm;
+    /**
+     * Handle a calendarCell selected
+     */
+    selectCalendarCell(cell: CalendarCell): void;
+    private selectYear;
+    /**
+     * Generate the previous year list
+     */
+    prevYearList(event: any): void;
+    /**
+     * Generate the next year list
+     */
+    nextYearList(event: any): void;
+    /** Whether the previous period button is enabled */
+    previousEnabled(): boolean;
+    /** Whether the next period button is enabled */
+    nextEnabled(): boolean;
+    handleCalendarKeydown(event: KeyboardEvent): void;
+    /**
+     * Creates an CalendarCell for the given year.
+     */
+    private createYearCell;
+    /** Whether the given year is enabled */
+    private isYearEnabled;
+    private isSameYearList;
+    /**
+     * Get a valid date object
+     */
+    private getValidDate;
+    private focusActiveCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiYearViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiYearViewComponent<any>, "nxt-date-time-multi-year-view", never, { "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selecteds": { "alias": "selecteds"; "required": false; "isSignal": true; }; "_pickerMomentInput": { "alias": "pickerMoment"; "required": false; "isSignal": true; }; "dateTimeFilter": { "alias": "dateTimeFilter"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, { "change": "change"; "yearSelected": "yearSelected"; "pickerMomentChange": "pickerMomentChange"; "keyboardEnter": "keyboardEnter"; }, never, never, true, never>;
+}
+
+declare class YearViewComponent<T> {
+    private readonly dateTimeAdapter;
+    private readonly dateTimeFormats;
+    /**
+     * The select mode of the picker;
+     */
+    readonly selectMode: _angular_core.InputSignal<SelectMode>;
+    /** The currently selected date */
+    readonly selected: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    readonly selecteds: _angular_core.InputSignalWithTransform<(T | undefined)[], (T | undefined)[]>;
+    readonly pickerMoment: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /**
+     * A function used to filter which dates are selectable
+     */
+    readonly dateTimeFilter: _angular_core.InputSignal<DateFilter<T> | undefined>;
+    /** The minimum selectable date */
+    readonly min: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The maximum selectable date */
+    readonly max: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    private readonly monthNames;
+    private readonly monthsData;
+    private _months?;
+    readonly months: _angular_core.Signal<CalendarCell[][] | undefined>;
+    readonly activeCell: _angular_core.Signal<number | undefined>;
+    readonly isInSingleMode: _angular_core.Signal<boolean>;
+    readonly isInRangeMode: _angular_core.Signal<boolean>;
+    private _todayMonth?;
+    readonly todayMonth: _angular_core.Signal<number | undefined>;
+    /**
+     * An array to hold all selectedDates' month value
+     * the value is the month number in current year
+     */
+    readonly selectedMonths: _angular_core.Signal<(number | undefined)[]>;
+    /**
+     * Callback to invoke when a new month is selected
+     */
+    readonly change: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Emits the selected year
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly monthSelected: _angular_core.OutputEmitterRef<T>;
+    /** Emits when any date is activated */
+    readonly pickerMomentChange: _angular_core.OutputEmitterRef<T>;
+    /** Emits when use keyboard enter to select a calendar cell */
+    readonly keyboardEnter: _angular_core.OutputEmitterRef<void>;
+    /** The body of calendar table */
+    private readonly calendarBodyElm;
+    /**
+     * Handle a calendarCell selected
+     */
+    selectCalendarCell(cell: CalendarCell): void;
+    /**
+     * Handle a new month selected
+     */
+    private selectMonth;
+    /**
+     * Handle keydown event on calendar body
+     */
+    handleCalendarKeydown(event: KeyboardEvent): void;
+    /**
+     * Creates an CalendarCell for the given month.
+     */
+    private createMonthCell;
+    /**
+     * Check if the given month is enable
+     */
+    private isMonthEnabled;
+    /**
+     * Gets the month in this year that the given Date falls on.
+     * Returns undefined if the given Date is in another year.
+     */
+    private getMonthInCurrentYear;
+    /**
+     * Check the given dates are in the same year
+     */
+    private hasSameYear;
+    /**
+     * Get a valid date object
+     */
+    private getValidDate;
+    private focusActiveCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YearViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YearViewComponent<any>, "nxt-date-time-year-view", never, { "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selecteds": { "alias": "selecteds"; "required": false; "isSignal": true; }; "pickerMoment": { "alias": "pickerMoment"; "required": false; "isSignal": true; }; "dateTimeFilter": { "alias": "dateTimeFilter"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, { "change": "change"; "monthSelected": "monthSelected"; "pickerMomentChange": "pickerMomentChange"; "keyboardEnter": "keyboardEnter"; }, never, never, true, never>;
+}
+
+declare class CalendarComponent<T> {
+    private readonly elmRef;
+    private readonly pickerIntl;
+    private readonly ngZone;
+    private readonly dateTimeAdapter;
+    private readonly dateTimeFormats;
+    /**
+     * Date filter for the month and year view
+     */
+    readonly dateTimeFilter: _angular_core.InputSignal<DateFilter<T> | undefined>;
+    /**
+     * Set the first day of week
+     */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number>;
+    /** The minimum selectable date */
+    readonly min: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The maximum selectable date */
+    readonly max: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The current picker moment */
+    readonly _pickerMomentInput: _angular_core.InputSignal<T | undefined>;
+    /** Settable signal for pickerMoment */
+    private readonly _pickerMoment;
+    readonly pickerMoment: _angular_core.Signal<T>;
+    readonly selectMode: _angular_core.InputSignal<SelectMode | undefined>;
+    /** The currently selected moment */
+    readonly selected: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    readonly selecteds: _angular_core.InputSignalWithTransform<(T | undefined)[], (T | undefined)[]>;
+    /**
+     * The view that the calendar should start in
+     */
+    readonly startView: _angular_core.InputSignal<"year" | "month" | "multi-years">;
+    /**
+     * Whether to hide dates in other months at the start or end of the current month
+     */
+    readonly hideOtherMonths: _angular_core.InputSignal<boolean>;
+    /** Emits when the currently picker moment changes */
+    readonly pickerMomentChange: _angular_core.OutputEmitterRef<T>;
+    /** Emits when the currently selected date changes */
+    readonly selectedChange: _angular_core.OutputEmitterRef<T | undefined>;
+    /** Emits when any date is selected */
+    readonly userSelection: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits the selected year
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly yearSelected: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Emits the selected month
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly monthSelected: _angular_core.OutputEmitterRef<T>;
+    readonly periodButtonText: _angular_core.Signal<string>;
+    readonly periodButtonLabel: _angular_core.Signal<string>;
+    readonly prevButtonLabel: _angular_core.Signal<string | undefined>;
+    readonly nextButtonLabel: _angular_core.Signal<string | undefined>;
+    readonly currentView: _angular_core.WritableSignal<"year" | "month" | "multi-years">;
+    readonly isInSingleMode: _angular_core.Signal<boolean>;
+    readonly isInRangeMode: _angular_core.Signal<boolean>;
+    readonly showControlArrows: _angular_core.Signal<boolean>;
+    readonly isMonthView: _angular_core.Signal<boolean>;
+    /**
+     * Date filter for the month and year view
+     */
+    dateTimeFilterForViews: (date?: T) => boolean;
+    constructor();
+    /**
+     * Toggle between month view and year view
+     */
+    toggleViews(): void;
+    /**
+     * Handles user clicks on the previous button.
+     */
+    previousClicked(): void;
+    /**
+     * Handles user clicks on the next button.
+     */
+    nextClicked(): void;
+    dateSelected(date?: T): void;
+    /**
+     * Change the pickerMoment value and switch to a specific view
+     */
+    goToDateInView(date: T, view: 'month' | 'year' | 'multi-years'): void;
+    /**
+     * Change the pickerMoment value
+     */
+    handlePickerMomentChange(date: T): void;
+    userSelected(): void;
+    /**
+     * Whether the previous period button is enabled.
+     */
+    prevButtonEnabled(): boolean;
+    /**
+     * Whether the next period button is enabled.
+     */
+    nextButtonEnabled(): boolean;
+    /**
+     * Focus to the host element
+     */
+    focusActiveCell(): void;
+    selectYearInMultiYearView(normalizedYear: T): void;
+    selectMonthInYearView(normalizedMonth: T): void;
+    /**
+     * Whether the two dates represent the same view in the current view mode (month or year).
+     */
+    private isSameView;
+    /**
+     * Get a valid date object
+     */
+    private getValidDate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarComponent<any>, "nxt-date-time-calendar", never, { "dateTimeFilter": { "alias": "dateTimeFilter"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "_pickerMomentInput": { "alias": "pickerMoment"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "selecteds": { "alias": "selecteds"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "hideOtherMonths": { "alias": "hideOtherMonths"; "required": false; "isSignal": true; }; }, { "pickerMomentChange": "pickerMomentChange"; "selectedChange": "selectedChange"; "userSelection": "userSelection"; "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; }, never, never, true, never>;
+}
+
+declare class DateTimeInlineComponent<T> extends DateTimeDirective<T> implements OnInit, ControlValueAccessor {
+    private readonly container;
+    /**
+     * Set the type of the dateTime picker
+     *
+     * -    `'both'` - show both calendar and timer
+     * -    `'calendar'` - show only calendar
+     * -    `'timer'` - show only timer
+     */
+    readonly pickerType: _angular_core.InputSignal<PickerType>;
+    /** Whether the date time picker should be disabled */
+    readonly _disabled: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * The picker select mode
+     *
+     * -    `'single'` - select a single date
+     * -    `'range'` - select a range [from, to]
+     * -    `'rangeFrom'` - an open range with a fixed start date
+     * -    `'rangeTo'` - an open range with a fixed end date
+     */
+    readonly selectMode: _angular_core.InputSignal<SelectMode>;
+    readonly _valueInput: _angular_core.InputSignal<T | undefined>;
+    private readonly _value;
+    readonly value: _angular_core.Signal<T | undefined>;
+    readonly _valuesInput: _angular_core.InputSignal<(T | undefined)[] | undefined>;
+    private readonly _values;
+    readonly values: _angular_core.Signal<(T | undefined)[]>;
+    /**
+     * The date to show when picker opens
+     *
+     * Defaults to selected date (if available) or current date.
+     */
+    readonly _startAt: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    readonly startAt: _angular_core.Signal<T | undefined>;
+    /** A function to filter available date & time */
+    readonly dateTimeFilter: _angular_core.InputSignal<DateFilter<T> | undefined>;
+    /** The minimum valid date */
+    readonly min: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The maximum valid date */
+    readonly max: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /**
+     * Emits selected year in multi-year view
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly yearSelected: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Emits selected month in year view
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly monthSelected: _angular_core.OutputEmitterRef<T>;
+    readonly selected: _angular_core.WritableSignal<T | undefined>;
+    readonly selecteds: _angular_core.WritableSignal<(T | undefined)[]>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly pickerMode: _angular_core.Signal<PickerMode>;
+    readonly isInSingleMode: _angular_core.Signal<boolean>;
+    readonly isInRangeMode: _angular_core.Signal<boolean>;
+    private onModelChange?;
+    private onModelTouched?;
+    ngOnInit(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    select(date: T[] | T): void;
+    /**
+     * Emits the selected year in multi-year view
+     */
+    selectYear(normalizedYear: T): void;
+    /**
+     * Emits selected month in year view
+     */
+    selectMonth(normalizedMonth: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeInlineComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateTimeInlineComponent<any>, "nxt-date-time-inline", never, { "pickerType": { "alias": "pickerType"; "required": false; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "_valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "_valuesInput": { "alias": "values"; "required": false; "isSignal": true; }; "_startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "dateTimeFilter": { "alias": "dateTimeFilter"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, { "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; }, never, never, true, never>;
+}
+
+declare class DateTimeComponent<T> extends DateTimeDirective<T> implements OnDestroy {
+    private readonly overlay;
+    private readonly viewContainerRef;
+    private readonly dialogService;
+    private readonly ngZone;
+    private readonly defaultScrollStrategy;
+    private readonly document;
+    /** Custom class for the picker backdrop */
+    readonly backdropClass: _angular_core.InputSignal<string | string[] | undefined>;
+    /** Custom class for the picker overlay pane */
+    readonly panelClass: _angular_core.InputSignal<string | string[] | undefined>;
+    /**
+     * The date to show when picker opens
+     *
+     * Defaults to selected date (if available) or current date.
+     */
+    readonly _startAt: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    readonly startAt: _angular_core.Signal<T | undefined>;
+    /**
+     * Set the type of the dateTime picker
+     *
+     * -    `'both'` - show both calendar and timer
+     * -    `'calendar'` - show only calendar
+     * -    `'timer'` - show only timer
+     */
+    readonly pickerType: _angular_core.InputSignal<PickerType>;
+    /**
+     * The style the picker would open as
+     *
+     * -    `'popup'` - display picker attached to the trigger element
+     * -    `'dialog'` - display picker as a dialog
+     */
+    readonly pickerMode: _angular_core.InputSignalWithTransform<PickerMode, PickerMode>;
+    /** Whether the date time picker should be disabled */
+    readonly _disabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    /** Whether the calendar is open */
+    readonly _isOpen: _angular_core.InputSignal<boolean>;
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    /**
+     * The scroll strategy when the picker is open (see [CDK documentation](https://material.angular.io/cdk/overlay/overview#scroll-strategies))
+     */
+    readonly scrollStrategy: _angular_core.InputSignal<ScrollStrategy | undefined>;
+    /**
+     * Callback when the picker is opened
+     */
+    readonly afterPickerOpened: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Callback when the picker is closed
+     */
+    readonly afterPickerClosed: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emits selected year in multi-year view
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly yearSelected: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Emits selected month in year view
+     *
+     * This doesn't imply a change on the selected date.
+     */
+    readonly monthSelected: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Emits when picker open state changes
+     */
+    readonly isOpenChange: _angular_core.OutputEmitterRef<boolean>;
+    /**
+     * Emit when the selected value has been confirmed
+     */
+    readonly confirmSelectedChange: _angular_core.OutputEmitterRef<T | (T | undefined)[]>;
+    /**
+     * Emits when the date time picker is disabled
+     */
+    readonly disabledChange: _angular_core.OutputEmitterRef<boolean>;
+    private pickerContainerPortal?;
+    private pickerContainer?;
+    private popupRef?;
+    private dialogRef?;
+    private hidePickerStreamSub?;
+    private confirmSelectedStreamSub?;
+    private pickerOpenedStreamSub?;
+    /** The element that was focused before the date time picker was isOpen */
+    private focusedElementBeforeOpen?;
+    private readonly _dtInput;
+    readonly dtInput: _angular_core.Signal<DateTimeInputDirective<T> | undefined>;
+    private readonly valueChange;
+    readonly selected: _angular_core.WritableSignal<T | undefined>;
+    readonly selecteds: _angular_core.WritableSignal<(T | undefined)[]>;
+    /** The minimum selectable date */
+    readonly min: _angular_core.Signal<T | undefined>;
+    /** The maximum selectable date */
+    readonly max: _angular_core.Signal<T | undefined>;
+    readonly dateTimeFilter: _angular_core.Signal<nxt_pick_datetime.DateFilter<T> | undefined>;
+    readonly selectMode: _angular_core.Signal<nxt_pick_datetime.SelectMode | undefined>;
+    readonly isInSingleMode: _angular_core.Signal<boolean>;
+    readonly isInRangeMode: _angular_core.Signal<boolean>;
+    constructor();
+    ngOnDestroy(): void;
+    registerInput(inputDirective: DateTimeInputDirective<T>): void;
+    open(): void;
+    /**
+     * Selects the given date
+     */
+    select(date: T[] | T): void;
+    /**
+     * Emits the selected year in multi-year view
+     */
+    selectYear(normalizedYear: T): void;
+    /**
+     * Emits selected month in year view
+     */
+    selectMonth(normalizedMonth: T): void;
+    /**
+     * Hide the picker
+     */
+    close(): void;
+    /**
+     * Confirm the selected value
+     */
+    confirmSelect(_event?: any): void;
+    /**
+     * Open the picker as a dialog
+     */
+    private openAsDialog;
+    /**
+     * Open the picker as popup
+     */
+    private openAsPopup;
+    private createPopup;
+    /**
+     * Create the popup PositionStrategy.
+     */
+    private createPopupPositionStrategy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateTimeComponent<any>, "nxt-date-time", never, { "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "_startAt": { "alias": "startAt"; "required": false; "isSignal": true; }; "pickerType": { "alias": "pickerType"; "required": false; "isSignal": true; }; "pickerMode": { "alias": "pickerMode"; "required": false; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "_isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; "isSignal": true; }; }, { "afterPickerOpened": "open"; "afterPickerClosed": "close"; "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; "isOpenChange": "isOpenChange"; "confirmSelectedChange": "confirmSelectedChange"; "disabledChange": "disabledChange"; }, never, never, true, never>;
+}
+
+interface DateTimeInputEvent<T> {
+    source: DateTimeInputDirective<T>;
+    value?: T | Array<T | undefined>;
+    input: HTMLInputElement;
+}
+declare class DateTimeInputDirective<T> implements OnInit, AfterContentInit, OnDestroy, ControlValueAccessor, Validator {
+    private readonly elmRef;
+    private readonly renderer;
+    private readonly dateTimeAdapter;
+    private readonly dateTimeFormats;
+    /**
+     * The date & time picker this input is associated with
+     */
+    readonly dateTime: _angular_core.InputSignal<DateTimeComponent<T> | undefined>;
+    /**
+     * A function to filter available date & time
+     */
+    readonly dateTimeFilter: _angular_core.InputSignal<DateFilter<T> | undefined>;
+    /** Whether the date & time picker input is disabled */
+    readonly _disabled: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.WritableSignal<boolean>;
+    /** The minimum valid date */
+    readonly min: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The maximum valid date */
+    readonly max: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /**
+     * The picker select mode
+     *
+     * -    `'single'` - select a single date
+     * -    `'range'` - select a range [from, to]
+     * -    `'rangeFrom'` - an open range with a fixed start date
+     * -    `'rangeTo'` - an open range with a fixed end date
+     */
+    readonly selectMode: _angular_core.InputSignal<SelectMode>;
+    /**
+     * The character to separate the 'from' and 'to' in input value
+     */
+    readonly rangeSeparator: _angular_core.InputSignal<string>;
+    readonly _valueInput: _angular_core.InputSignal<T | undefined>;
+    private readonly _value;
+    private readonly valueValidity;
+    private readonly parsedValue;
+    readonly value: _angular_core.Signal<T | undefined>;
+    readonly _valuesInput: _angular_core.InputSignal<(T | undefined)[]>;
+    private readonly _values;
+    private readonly valuesValidity;
+    private readonly parsedValues;
+    readonly values: _angular_core.Signal<(T | undefined)[]>;
+    private readonly nativeElementValue;
+    /**
+     * Callback to invoke when `change` event is fired on this `<input>`
+     */
+    readonly dateTimeChange: _angular_core.OutputEmitterRef<DateTimeInputEvent<T>>;
+    /**
+     * Callback to invoke when an `input` event is fired on this `<input>`.
+     */
+    readonly dateTimeInput: _angular_core.OutputEmitterRef<DateTimeInputEvent<T>>;
+    get elementRef(): ElementRef<HTMLInputElement>;
+    readonly isInSingleMode: _angular_core.Signal<boolean>;
+    readonly isInRangeMode: _angular_core.Signal<boolean>;
+    /** The date-time-picker that this input is associated with */
+    readonly dtPicker: _angular_core.WritableSignal<DateTimeComponent<T> | undefined>;
+    private dtPickerSub?;
+    private readonly lastValueValid;
+    private onModelChange?;
+    private onModelTouched?;
+    private validatorOnChange?;
+    /** The form control validator for whether the input parses */
+    private readonly parseValidator;
+    /** The form control validator for the min date */
+    private readonly minValidator;
+    /** The form control validator for the max date */
+    private readonly maxValidator;
+    /** The form control validator for the date filter */
+    private readonly filterValidator;
+    /**
+     * The form control validator for the range.
+     * Check whether the 'before' value is before the 'to' value
+     */
+    private readonly rangeValidator;
+    /** The combined form control validator for this input */
+    private readonly validator;
+    /** Emits when the value changes (either due to user input or programmatic change) */
+    readonly valueChange: _angular_core.OutputEmitterRef<T | (T | undefined)[] | undefined>;
+    /** Emits when the disabled state has changed */
+    readonly disabledChange: _angular_core.OutputEmitterRef<boolean>;
+    /** @internal */
+    readonly inputAriaOwns: _angular_core.Signal<string | undefined>;
+    /** @internal */
+    readonly minIso8601: _angular_core.Signal<string | undefined>;
+    /** @internal */
+    readonly maxIso8601: _angular_core.Signal<string | undefined>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    /**
+     * Open the picker when user hold alt + ArrowDown
+     */
+    handleKeydownOnHost(event: KeyboardEvent): void;
+    handleBlurOnHost(_event: Event): void;
+    handleInputOnHost(event: any): void;
+    handleChangeOnHost(_event: any): void;
+    /**
+     * Set the native input property 'value'
+     */
+    /**
+     * Convert a given obj to a valid date object
+     */
+    private getValidDate;
+    /**
+     * Convert a time string to a date-time string
+     * When pickerType is 'timer', the value in the picker's input is a time string.
+     * The dateTimeAdapter parse fn could not parse a time string to a Date Object.
+     * Therefore we need this fn to convert a time string to a date-time string.
+     */
+    private convertTimeStringToDateTimeString;
+    /**
+     * Handle input change in single mode
+     */
+    private changeInputInSingleMode;
+    /**
+     * Handle input change in rangeFrom or rangeTo mode
+     */
+    private changeInputInRangeFromToMode;
+    /**
+     * Handle input change in range mode
+     */
+    private changeInputInRangeMode;
+    /**
+     * Check if the two value is the same
+     */
+    private isSameValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeInputDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DateTimeInputDirective<any>, "input[nxtDateTime]", ["nxtDateTimeInput"], { "dateTime": { "alias": "nxtDateTime"; "required": false; "isSignal": true; }; "dateTimeFilter": { "alias": "dateTimeFilter"; "required": false; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "rangeSeparator": { "alias": "rangeSeparator"; "required": false; "isSignal": true; }; "_valueInput": { "alias": "value"; "required": false; "isSignal": true; }; "_valuesInput": { "alias": "values"; "required": false; "isSignal": true; }; }, { "dateTimeChange": "dateTimeChange"; "dateTimeInput": "dateTimeInput"; "valueChange": "valueChange"; "disabledChange": "disabledChange"; }, never, never, true, never>;
+}
+
+declare class DateTimeIntl {
+    /** A label for the up second button (used by screen readers).  */
+    readonly upSecondLabel: _angular_core.WritableSignal<string>;
+    /** A label for the down second button (used by screen readers).  */
+    readonly downSecondLabel: _angular_core.WritableSignal<string>;
+    /** A label for the up minute button (used by screen readers).  */
+    readonly upMinuteLabel: _angular_core.WritableSignal<string>;
+    /** A label for the down minute button (used by screen readers).  */
+    readonly downMinuteLabel: _angular_core.WritableSignal<string>;
+    /** A label for the up hour button (used by screen readers).  */
+    readonly upHourLabel: _angular_core.WritableSignal<string>;
+    /** A label for the down hour button (used by screen readers).  */
+    readonly downHourLabel: _angular_core.WritableSignal<string>;
+    /** A label for the previous month button (used by screen readers) */
+    readonly prevMonthLabel: _angular_core.WritableSignal<string>;
+    /** A label for the next month button (used by screen readers) */
+    readonly nextMonthLabel: _angular_core.WritableSignal<string>;
+    /** A label for the previous year button (used by screen readers) */
+    readonly prevYearLabel: _angular_core.WritableSignal<string>;
+    /** A label for the next year button (used by screen readers) */
+    readonly nextYearLabel: _angular_core.WritableSignal<string>;
+    /** A label for the previous multi-year button (used by screen readers) */
+    readonly prevMultiYearLabel: _angular_core.WritableSignal<string>;
+    /** A label for the next multi-year button (used by screen readers) */
+    readonly nextMultiYearLabel: _angular_core.WritableSignal<string>;
+    /** A label for the 'switch to month view' button (used by screen readers) */
+    readonly switchToMonthViewLabel: _angular_core.WritableSignal<string>;
+    /** A label for the 'switch to year view' button (used by screen readers) */
+    readonly switchToMultiYearViewLabel: _angular_core.WritableSignal<string>;
+    /** A label for the cancel button */
+    readonly cancelBtnLabel: _angular_core.WritableSignal<string>;
+    /** A label for the set button */
+    readonly setBtnLabel: _angular_core.WritableSignal<string>;
+    /** A label for the range 'from' in picker info */
+    readonly rangeFromLabel: _angular_core.WritableSignal<string>;
+    /** A label for the range 'to' in picker info */
+    readonly rangeToLabel: _angular_core.WritableSignal<string>;
+    /** A label for the hour12 button (AM) */
+    readonly hour12AMLabel: _angular_core.WritableSignal<string>;
+    /** A label for the hour12 button (PM) */
+    readonly hour12PMLabel: _angular_core.WritableSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeIntl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DateTimeIntl>;
+}
+
+declare class DateTimeTriggerDirective<T> {
+    readonly dtPicker: _angular_core.InputSignal<DateTimeComponent<T> | undefined>;
+    readonly _disabled: _angular_core.InputSignal<boolean | undefined>;
+    readonly disabled: _angular_core.Signal<boolean>;
+    handleClickOnHost(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeTriggerDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DateTimeTriggerDirective<any>, "[nxtDateTimeTrigger]", never, { "dtPicker": { "alias": "nxtDateTimeTrigger"; "required": false; "isSignal": true; }; "_disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class TimerComponent<T> {
+    private readonly ngZone;
+    private readonly elmRef;
+    private readonly pickerIntl;
+    private readonly dateTimeAdapter;
+    /** The current picker moment */
+    readonly pickerMoment: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The minimum selectable date time */
+    readonly min: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /** The maximum selectable date time */
+    readonly max: _angular_core.InputSignalWithTransform<T | undefined, T | undefined>;
+    /**
+     * Whether to show the second's timer
+     */
+    readonly showSecondsTimer: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether the timer is in hour12 format
+     */
+    readonly hour12Timer: _angular_core.InputSignal<boolean>;
+    /**
+     * Hours to change per step
+     */
+    readonly stepHour: _angular_core.InputSignal<number>;
+    /**
+     * Minutes to change per step
+     */
+    readonly stepMinute: _angular_core.InputSignal<number>;
+    /**
+     * Seconds to change per step
+     */
+    readonly stepSecond: _angular_core.InputSignal<number>;
+    readonly hourValue: _angular_core.Signal<number>;
+    private readonly hoursWithPM;
+    private _isPM;
+    private readonly isPM;
+    /**
+     * The value would be displayed in hourBox.
+     * We need this because the value displayed in hourBox it not
+     * the same as the hourValue when the timer is in hour12Timer mode.
+     */
+    readonly hourBoxValue: _angular_core.Signal<number>;
+    readonly minuteValue: _angular_core.Signal<number>;
+    readonly secondValue: _angular_core.Signal<number>;
+    readonly upHourButtonLabel: _angular_core.Signal<string>;
+    readonly downHourButtonLabel: _angular_core.Signal<string>;
+    readonly upMinuteButtonLabel: _angular_core.Signal<string>;
+    readonly downMinuteButtonLabel: _angular_core.Signal<string>;
+    readonly upSecondButtonLabel: _angular_core.Signal<string>;
+    readonly downSecondButtonLabel: _angular_core.Signal<string>;
+    readonly hour12ButtonLabel: _angular_core.Signal<string>;
+    readonly selectedChange: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Focus to the host element
+     */
+    focus(): void;
+    /**
+     * Set the hour value via typing into timer box input
+     * We need this to handle the hour value when the timer is in hour12 mode
+     */
+    setHourValueViaInput(hours: number): void;
+    setHourValue(hours: number): void;
+    setMinuteValue(minutes: number): void;
+    setSecondValue(seconds: number): void;
+    setMeridiem(event: any): void;
+    /**
+     * Check if the up hour button is enabled
+     */
+    readonly upHourEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Check if the down hour button is enabled
+     */
+    readonly downHourEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Check if the up minute button is enabled
+     */
+    readonly upMinuteEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Check if the down minute button is enabled
+     */
+    readonly downMinuteEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Check if the up second button is enabled
+     */
+    readonly upSecondEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Check if the down second button is enabled
+     */
+    readonly downSecondEnabled: _angular_core.Signal<boolean>;
+    /**
+     * PickerMoment's hour value +/- certain amount and compare it to the give date
+     * 1 is after the comparedDate
+     * -1 is before the comparedDate
+     * 0 is equal the comparedDate
+     */
+    private compareHours;
+    /**
+     * PickerMoment's minute value +/- certain amount and compare it to the give date
+     * 1 is after the comparedDate
+     * -1 is before the comparedDate
+     * 0 is equal the comparedDate
+     */
+    private compareMinutes;
+    /**
+     * PickerMoment's second value +/- certain amount and compare it to the give date
+     * 1 is after the comparedDate
+     * -1 is before the comparedDate
+     * 0 is equal the comparedDate
+     */
+    private compareSeconds;
+    /**
+     * Get a valid date object
+     */
+    private getValidDate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimerComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimerComponent<any>, "nxt-date-time-timer", never, { "pickerMoment": { "alias": "pickerMoment"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "showSecondsTimer": { "alias": "showSecondsTimer"; "required": false; "isSignal": true; }; "hour12Timer": { "alias": "hour12Timer"; "required": false; "isSignal": true; }; "stepHour": { "alias": "stepHour"; "required": false; "isSignal": true; }; "stepMinute": { "alias": "stepMinute"; "required": false; "isSignal": true; }; "stepSecond": { "alias": "stepSecond"; "required": false; "isSignal": true; }; }, { "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+/** @deprecated use standalone imports */
+declare class DateTimeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateTimeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DateTimeModule, never, [typeof CalendarComponent, typeof TimerComponent, typeof DateTimeTriggerDirective, typeof DateTimeInputDirective, typeof DateTimeComponent, typeof DateTimeInlineComponent, typeof MultiYearViewComponent, typeof YearViewComponent, typeof MonthViewComponent], [typeof CalendarComponent, typeof TimerComponent, typeof DateTimeTriggerDirective, typeof DateTimeInputDirective, typeof DateTimeComponent, typeof DateTimeInlineComponent, typeof MultiYearViewComponent, typeof YearViewComponent, typeof MonthViewComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DateTimeModule>;
+}
+
+export { CalendarComponent, DateTimeAdapter, DateTimeComponent, DateTimeInlineComponent, DateTimeInputDirective, DateTimeIntl, DateTimeModule, DateTimeTriggerDirective, MonthViewComponent, MultiYearViewComponent, NXT_DATE_TIME_FORMATS, TimerComponent, YearViewComponent };
+export type { DateFilter, DateTimeFormats, DateTimeInputEvent, PickerMode, PickerType, RenderItem, SelectMode, ViewType };