@dintecom/ngx-datetime-picker 22.0.0

package/types/dintecom-ngx-datetime-picker.d.ts

@@ -0,0 +1,2365 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, EnvironmentProviders, ViewContainerRef, OnInit, EventEmitter, ComponentRef, EmbeddedViewRef, OutputEmitterRef, AfterContentInit, OnDestroy, ElementRef, ChangeDetectorRef, OnChanges, SimpleChanges, AfterViewChecked, AfterViewInit, AnimationCallbackEvent, PipeTransform } from '@angular/core';
+import * as i1 from '@angular/common';
+import * as i3 from '@angular/cdk/overlay';
+import { ScrollStrategy, Overlay } from '@angular/cdk/overlay';
+import * as i2 from '@angular/cdk/a11y';
+import * as i4 from '@angular/cdk/portal';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { ControlValueAccessor, Validator, AbstractControl } from '@angular/forms';
+import { Subject, Observable } from 'rxjs';
+import * as i1$1 from '@angular/cdk/platform';
+
+declare function defaultOptionsFactory(): Options;
+declare function multiYearOptionsFactory(options: Options): {
+    yearsPerRow: number;
+    yearRows: number;
+};
+interface Options {
+    multiYear: {
+        yearsPerRow: number;
+        yearRows: number;
+    };
+}
+declare class DefaultOptions {
+    static create(): Options;
+}
+declare abstract class OptionsTokens {
+    static all: InjectionToken<Options>;
+    static multiYear: InjectionToken<{
+        yearsPerRow: number;
+        yearRows: number;
+    }>;
+}
+declare const optionsProviders: Provider[];
+
+/**
+ * provide-date-time.ts
+ * Provider functions for OwlDateTime in standalone mode
+ */
+
+/**
+ * Provides the core OwlDateTime functionality without any date adapter.
+ * You must also provide a date adapter using `provideOwlNativeDateTime()` or `provideOwlUnixTimestampDateTime()`.
+ *
+ * This includes:
+ * - Date time picker internationalization service
+ * - Scroll strategy for picker overlay
+ * - Dialog service and scroll strategy (for dialog mode)
+ * - Default options configuration
+ *
+ * @example
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlNativeDateTime()
+ *   ]
+ * });
+ * ```
+ */
+declare function provideOwlDateTime(): EnvironmentProviders;
+/**
+ * Provides custom options for OwlDateTime.
+ * This is optional - default options will be used if not provided.
+ *
+ * @param options - Custom options for multi-year view configuration
+ *
+ * @example
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlNativeDateTime(),
+ *     provideOwlDateTimeOptions({
+ *       multiYear: {
+ *         yearsPerRow: 4,
+ *         yearRows: 5
+ *       }
+ *     })
+ *   ]
+ * });
+ * ```
+ */
+declare function provideOwlDateTimeOptions(options: Partial<Options>): Provider[];
+/**
+ * Provides the core OwlDateTime functionality for component-level usage.
+ * Returns regular Provider[] instead of EnvironmentProviders, allowing use in @Component({ providers: [] }).
+ *
+ * Use this when you want to provide OwlDateTime configuration at the component level
+ * rather than globally in main.ts.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     ...owlDateTimeProviders(),
+ *     ...owlNativeDateTimeProviders()
+ *   ]
+ * })
+ * export class MyPickerComponent { }
+ * ```
+ */
+declare function owlDateTimeProviders(): Provider[];
+
+/**
+ * date-time-format.class
+ */
+
+interface OwlDateTimeFormats {
+    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 OWL_DATE_TIME_FORMATS: InjectionToken<OwlDateTimeFormats>;
+
+/**
+ * provide-native-date-time.ts
+ * Provider functions for native JavaScript Date adapter
+ */
+
+/**
+ * Provides the native JavaScript Date adapter for OwlDateTime.
+ * This includes both the adapter and the default date formats.
+ *
+ * @example
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlNativeDateTime()
+ *   ]
+ * });
+ * ```
+ */
+declare function provideOwlNativeDateTime(): EnvironmentProviders;
+/**
+ * Provides the native JavaScript Date adapter with custom formats.
+ *
+ * @param formats - Custom date time formats
+ *
+ * @example
+ * ```typescript
+ * const customFormats: OwlDateTimeFormats = {
+ *   parseInput: 'DD/MM/YYYY HH:mm',
+ *   fullPickerInput: 'DD/MM/YYYY HH:mm:ss',
+ *   datePickerInput: 'DD/MM/YYYY',
+ *   timePickerInput: 'HH:mm:ss',
+ *   monthYearLabel: 'MMM YYYY',
+ *   dateA11yLabel: 'LL',
+ *   monthYearA11yLabel: 'MMMM YYYY',
+ * };
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlNativeDateTimeWithFormats(customFormats)
+ *   ]
+ * });
+ * ```
+ */
+declare function provideOwlNativeDateTimeWithFormats(formats: OwlDateTimeFormats): EnvironmentProviders;
+/**
+ * Provides the native JavaScript Date adapter for component-level usage.
+ * Returns regular Provider[] instead of EnvironmentProviders, allowing use in @Component({ providers: [] }).
+ *
+ * Use this when you want to provide the date adapter at the component level
+ * rather than globally in main.ts.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   providers: [
+ *     ...owlDateTimeProviders(),
+ *     ...owlNativeDateTimeProviders()
+ *   ]
+ * })
+ * export class MyPickerComponent { }
+ * ```
+ */
+declare function owlNativeDateTimeProviders(): Provider[];
+/**
+ * Provides the native JavaScript Date adapter with custom formats for component-level usage.
+ * Returns regular Provider[] instead of EnvironmentProviders, allowing use in @Component({ providers: [] }).
+ *
+ * @param formats - Custom date time formats
+ *
+ * @example
+ * ```typescript
+ * const customFormats: OwlDateTimeFormats = {
+ *   parseInput: 'DD/MM/YYYY HH:mm',
+ *   fullPickerInput: 'DD/MM/YYYY HH:mm:ss',
+ *   datePickerInput: 'DD/MM/YYYY',
+ *   timePickerInput: 'HH:mm:ss',
+ *   monthYearLabel: 'MMM YYYY',
+ *   dateA11yLabel: 'LL',
+ *   monthYearA11yLabel: 'MMMM YYYY',
+ * };
+ *
+ * @Component({
+ *   providers: [
+ *     ...owlDateTimeProviders(),
+ *     ...owlNativeDateTimeProvidersWithFormats(customFormats)
+ *   ]
+ * })
+ * export class MyPickerComponent { }
+ * ```
+ */
+declare function owlNativeDateTimeProvidersWithFormats(formats: OwlDateTimeFormats): Provider[];
+
+/**
+ * provide-unix-timestamp-date-time.ts
+ * Provider functions for Unix timestamp adapter
+ */
+
+/**
+ * Provides the Unix timestamp adapter for OwlDateTime.
+ * This includes both the adapter and the default date formats.
+ *
+ * @example
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlUnixTimestampDateTime()
+ *   ]
+ * });
+ * ```
+ */
+declare function provideOwlUnixTimestampDateTime(): EnvironmentProviders;
+/**
+ * Provides the Unix timestamp adapter with custom formats.
+ *
+ * @param formats - Custom date time formats
+ *
+ * @example
+ * ```typescript
+ * const customFormats: OwlDateTimeFormats = {
+ *   parseInput: 'X',
+ *   fullPickerInput: 'X',
+ *   datePickerInput: 'X',
+ *   timePickerInput: 'X',
+ *   monthYearLabel: 'MMM YYYY',
+ *   dateA11yLabel: 'LL',
+ *   monthYearA11yLabel: 'MMMM YYYY',
+ * };
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlUnixTimestampDateTimeWithFormats(customFormats)
+ *   ]
+ * });
+ * ```
+ */
+declare function provideOwlUnixTimestampDateTimeWithFormats(formats: OwlDateTimeFormats): EnvironmentProviders;
+
+/**
+ * provide-dialog.ts
+ * Provider functions for OwlDialog in standalone mode
+ */
+
+/**
+ * Provides the OwlDialog service and its dependencies.
+ * This is required for dialog mode date-time picker.
+ *
+ * Note: This is automatically included when using `provideOwlDateTime()`,
+ * so you typically don't need to call this separately.
+ *
+ * @example
+ * ```typescript
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDialog()
+ *   ]
+ * });
+ * ```
+ */
+declare function provideOwlDialog(): EnvironmentProviders;
+
+interface IDateTimePickerAnimationEvent {
+    phaseName: 'start' | 'done';
+    toState: 'enter' | 'leave';
+}
+
+/**
+ * dialog-config.class
+ */
+
+/** Possible overrides for a dialog's position. */
+interface DialogPosition {
+    /** Override for the dialog's top position. */
+    top?: string;
+    /** Override for the dialog's bottom position. */
+    bottom?: string;
+    /** Override for the dialog's left position. */
+    left?: string;
+    /** Override for the dialog's right position. */
+    right?: string;
+}
+interface OwlDialogConfigInterface {
+    /**
+     * ID of the element that describes the dialog.
+     */
+    ariaDescribedBy?: string | null;
+    /**
+     * Whether to focus the dialog when the dialog is opened
+     */
+    autoFocus?: boolean;
+    /** Whether the dialog has a backdrop. */
+    hasBackdrop?: boolean;
+    /**
+     * Custom style for the backdrop
+     * */
+    backdropStyle?: any;
+    /** Data being injected into the child component. */
+    data?: any;
+    /** Whether the user can use escape or clicking outside to close a modal. */
+    disableClose?: boolean;
+    /**
+     * ID for the modal. If omitted, a unique one will be generated.
+     */
+    id?: string;
+    /**
+     * The ARIA role of the dialog element.
+     */
+    role?: 'dialog' | 'alertdialog';
+    /**
+     * Custom class for the pane
+     * */
+    paneClass?: string | string[];
+    /**
+     * Mouse Event
+     * */
+    event?: MouseEvent;
+    /**
+     * Custom class for the backdrop
+     * */
+    backdropClass?: string | string[];
+    /**
+     * Whether the dialog should close when the user goes backwards/forwards in history.
+     * */
+    closeOnNavigation?: boolean;
+    /** Width of the dialog. */
+    width?: string;
+    /** Height of the dialog. */
+    height?: string;
+    /**
+     * The min-width of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    minWidth?: number | string;
+    /**
+     * The min-height of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    minHeight?: number | string;
+    /**
+     * The max-width of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    maxWidth?: number | string;
+    /**
+     * The max-height of the overlay panel.
+     * If a number is provided, pixel units are assumed.
+     * */
+    maxHeight?: number | string;
+    /** Position overrides. */
+    position?: DialogPosition;
+    /**
+     * The scroll strategy when the dialog is open
+     * Learn more this from https://material.angular.io/cdk/overlay/overview#scroll-strategies
+     * */
+    scrollStrategy?: ScrollStrategy;
+    viewContainerRef?: ViewContainerRef;
+}
+
+declare class OwlDialogContainerComponent extends BasePortalOutlet implements OnInit {
+    private changeDetector;
+    private elementRef;
+    private focusTrapFactory;
+    private document;
+    portalOutlet: CdkPortalOutlet | null;
+    /** The class that traps and manages focus within the dialog. */
+    private focusTrap;
+    /** ID of the element that should be considered as the dialog's label. */
+    ariaLabelledBy: string | null;
+    /** Emits when an animation state changes. */
+    animationStateChanged: EventEmitter<IDateTimePickerAnimationEvent>;
+    isAnimating: _angular_core.WritableSignal<boolean>;
+    private _config;
+    private _component;
+    get config(): OwlDialogConfigInterface;
+    private params;
+    private elementFocusedBeforeDialogWasOpened;
+    get owlDialogContainerClass(): boolean;
+    get owlDialogContainerTabIndex(): number;
+    get owlDialogContainerId(): string;
+    get owlDialogContainerRole(): string;
+    get owlDialogContainerAriaLabelledby(): string;
+    get owlDialogContainerAriaDescribedby(): string;
+    ngOnInit(): void;
+    /**
+     * Attach a ComponentPortal as content to this dialog container.
+     */
+    attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T>;
+    attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C>;
+    setConfig(config: OwlDialogConfigInterface): void;
+    onAnimationStart(event: IDateTimePickerAnimationEvent): void;
+    onAnimationDone(event: IDateTimePickerAnimationEvent): void;
+    startExitAnimation(): void;
+    /**
+     * Calculate origin used in the `zoomFadeInFrom()`
+     * for animation purpose
+     */
+    private calculateZoomOrigin;
+    /**
+     * Save the focused element before dialog was open
+     */
+    private savePreviouslyFocusedElement;
+    private trapFocus;
+    private restoreFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDialogContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlDialogContainerComponent, "owl-dialog-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * @deprecated Use `provideOwlDialog()` instead. This module will be removed in v21.0.0.
+ * Note: Dialog providers are automatically included in `provideOwlDateTime()`.
+ *
+ * Migration guide:
+ * ```typescript
+ * // Before:
+ * import { OwlDialogModule } from '@dintecom/ngx-datetime-picker';
+ * @NgModule({ imports: [OwlDialogModule] })
+ *
+ * // After (if using separately):
+ * import { provideOwlDialog } from '@dintecom/ngx-datetime-picker';
+ * providers: [provideOwlDialog()]
+ *
+ * // Or just use provideOwlDateTime() which includes it:
+ * import { provideOwlDateTime } from '@dintecom/ngx-datetime-picker';
+ * providers: [provideOwlDateTime()]
+ * ```
+ */
+declare class OwlDialogModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDialogModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<OwlDialogModule, never, [typeof i1.CommonModule, typeof i2.A11yModule, typeof i3.OverlayModule, typeof i4.PortalModule, typeof OwlDialogContainerComponent], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<OwlDialogModule>;
+}
+
+/**
+ * date-time-adapter.class
+ */
+
+/** InjectionToken for date time picker that can be used to override default locale code. */
+declare const OWL_DATE_TIME_LOCALE: InjectionToken<string>;
+/** Provider for OWL_DATE_TIME_LOCALE injection token. */
+declare const OWL_DATE_TIME_LOCALE_PROVIDER: {
+    provide: InjectionToken<string>;
+    useExisting: InjectionToken<string>;
+};
+declare abstract class DateTimeAdapter<T> {
+    /** The locale to use for all dates. */
+    protected locale: any;
+    /** A stream that emits when the locale changes. */
+    protected _localeChanges: Subject<string>;
+    get localeChanges(): Observable<string>;
+    firstMonthOfTheYear: number;
+    firstDayOfTheWeek: number;
+    /** 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;
+    /**
+     * 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, amount: number): T;
+    /**
+     * Add the specified number of months to the given date
+     */
+    abstract addCalendarMonths(date: T, amount: number): T;
+    /**
+     * Add the specified number of days to the given date
+     */
+    abstract addCalendarDays(date: T, amount: number): T;
+    /**
+     * Set the hours to the given date.
+     */
+    abstract setHours(date: T, amount: number): T;
+    /**
+     * Set the minutes to the given date.
+     */
+    abstract setMinutes(date: T, amount: number): T;
+    /**
+     * Set the seconds to the given date.
+     */
+    abstract setSeconds(date: T, 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, displayFormat: any): string;
+    /**
+     * Parse a user-provided value to a Date Object
+     */
+    abstract parse(value: any, parseFormat: any): T | null;
+    /**
+     * 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 | null;
+    /**
+     * Sets the locale used for all dates.
+     */
+    setLocale(locale: string): void;
+    /**
+    * Get the locale used for all dates.
+    * */
+    getLocale(): any;
+    /**
+     * Clamp the given date between min and max dates.
+     */
+    clampDate(date: T, min?: T | null, max?: T | null): T;
+}
+
+type PickerType = 'both' | 'calendar' | 'timer';
+type PickerMode = 'popup' | 'dialog' | 'inline';
+type SelectMode = 'single' | 'range' | 'rangeFrom' | 'rangeTo';
+declare enum DateView {
+    MONTH = "month",
+    YEAR = "year",
+    MULTI_YEARS = "multi-years"
+}
+type DateViewType = DateView.MONTH | DateView.YEAR | DateView.MULTI_YEARS;
+declare abstract class OwlDateTime<T> {
+    protected dateTimeAdapter: DateTimeAdapter<T>;
+    protected dateTimeFormats: OwlDateTimeFormats;
+    /**
+     * Whether to show the second's timer
+     */
+    private _showSecondsTimer;
+    get showSecondsTimer(): boolean;
+    set showSecondsTimer(val: boolean);
+    /**
+     * Whether the timer is in hour12 format
+     */
+    private _hour12Timer;
+    get hour12Timer(): boolean;
+    set hour12Timer(val: boolean);
+    /**
+     * The view that the calendar should start in.
+     */
+    readonly startView: _angular_core.InputSignal<DateViewType>;
+    /**
+     * Whether to show calendar weeks in the calendar
+     * */
+    readonly showCalendarWeeks: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to should only the year and multi-year views.
+     */
+    readonly yearOnly: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to should only the multi-year view.
+     */
+    readonly multiyearOnly: _angular_core.InputSignal<boolean>;
+    /**
+     * Hours to change per step
+     */
+    private _stepHour;
+    get stepHour(): number;
+    set stepHour(val: number);
+    /**
+     * Minutes to change per step
+     */
+    private _stepMinute;
+    get stepMinute(): number;
+    set stepMinute(val: number);
+    /**
+     * Seconds to change per step
+     */
+    private _stepSecond;
+    get stepSecond(): number;
+    set stepSecond(val: number);
+    /**
+     * Set the first day of week
+     */
+    private _firstDayOfWeek;
+    get firstDayOfWeek(): number;
+    set firstDayOfWeek(value: number);
+    /**
+     * Whether to hide dates in other months at the start or end of the current month.
+     */
+    private _hideOtherMonths;
+    get hideOtherMonths(): boolean;
+    set hideOtherMonths(val: boolean);
+    private readonly _id;
+    get id(): string;
+    abstract get selected(): T | null;
+    abstract get selecteds(): T[] | null;
+    abstract get dateTimeFilter(): (date: T | null) => boolean;
+    abstract get maxDateTime(): T | null;
+    abstract get minDateTime(): T | null;
+    abstract get selectMode(): SelectMode;
+    abstract get startAt(): T | null;
+    abstract get endAt(): T | null;
+    abstract get opened(): boolean;
+    abstract get pickerMode(): PickerMode;
+    abstract get pickerType(): PickerType;
+    abstract get isInSingleMode(): boolean;
+    abstract get isInRangeMode(): boolean;
+    abstract select(date: T | T[]): void;
+    abstract yearSelected: OutputEmitterRef<T>;
+    abstract monthSelected: OutputEmitterRef<T>;
+    abstract dateSelected: OutputEmitterRef<T>;
+    abstract selectYear(normalizedYear: T): void;
+    abstract selectMonth(normalizedMonth: T): void;
+    abstract selectDate(normalizedDate: T): void;
+    get formatString(): any;
+    /**
+     * Date Time Checker to check if the give dateTime is selectable
+     */
+    dateTimeChecker: (dateTime: T) => boolean;
+    get disabled(): boolean;
+    protected constructor(dateTimeAdapter: DateTimeAdapter<T>, dateTimeFormats: OwlDateTimeFormats);
+    protected getValidDate(obj: any): T | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDateTime<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OwlDateTime<any>, never, never, { "showSecondsTimer": { "alias": "showSecondsTimer"; "required": false; }; "hour12Timer": { "alias": "hour12Timer"; "required": false; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "showCalendarWeeks": { "alias": "showCalendarWeeks"; "required": false; "isSignal": true; }; "yearOnly": { "alias": "yearOnly"; "required": false; "isSignal": true; }; "multiyearOnly": { "alias": "multiyearOnly"; "required": false; "isSignal": true; }; "stepHour": { "alias": "stepHour"; "required": false; }; "stepMinute": { "alias": "stepMinute"; "required": false; }; "stepSecond": { "alias": "stepSecond"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "hideOtherMonths": { "alias": "hideOtherMonths"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const OWL_DATETIME_VALUE_ACCESSOR: any;
+declare const OWL_DATETIME_VALIDATORS: any;
+declare class OwlDateTimeInputDirective<T> implements OnInit, AfterContentInit, OnDestroy, ControlValueAccessor, Validator {
+    private elmRef;
+    private renderer;
+    private dateTimeAdapter;
+    private dateTimeFormats;
+    static ngAcceptInputType_disabled: boolean | '';
+    /**
+    * Required flag to be used for range of [null, null]
+    * */
+    private _required;
+    get required(): any;
+    set required(value: any);
+    /**
+     * The date time picker that this input is associated with.
+     * */
+    set owlDateTime(value: OwlDateTimeComponent<T>);
+    /**
+     * A function to filter date time
+     */
+    set owlDateTimeFilter(filter: (date: T | null) => boolean);
+    private _dateTimeFilter;
+    get dateTimeFilter(): (date: T | null) => boolean;
+    /** Whether the date time picker's input is disabled. */
+    protected readonly _disabled: _angular_core.ModelSignal<boolean>;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** The minimum valid date. */
+    private _min;
+    get min(): T | null;
+    set min(value: T | null);
+    /** The maximum valid date. */
+    private _max;
+    get max(): T | null;
+    set max(value: T | null);
+    /**
+     * The picker's select mode
+     */
+    private _selectMode;
+    get selectMode(): SelectMode;
+    set selectMode(mode: SelectMode);
+    /**
+     * The character to separate the 'from' and 'to' in input value
+     */
+    readonly rangeSeparator: _angular_core.InputSignal<string>;
+    private _value;
+    get value(): T | null;
+    set value(value: T | null);
+    private _values;
+    get values(): T[];
+    set values(values: T[]);
+    /**
+     * Callback to invoke when `change` event is fired on this `<input>`
+     * */
+    readonly dateTimeChange: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Callback to invoke when an `input` event is fired on this `<input>`.
+     * */
+    readonly dateTimeInput: _angular_core.OutputEmitterRef<any>;
+    get elementRef(): ElementRef;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    /** The date-time-picker that this input is associated with. */
+    dtPicker: OwlDateTimeComponent<T>;
+    private dtPickerSub;
+    private localeSub;
+    private lastValueValid;
+    private onModelChange;
+    private onModelTouched;
+    private validatorOnChange;
+    /** The form control validator for whether the input parses. */
+    private parseValidator;
+    /** The form control validator for the min date. */
+    private minValidator;
+    /** The form control validator for the max date. */
+    private maxValidator;
+    /** The form control validator for the date filter. */
+    private filterValidator;
+    /**
+     * The form control validator for the range.
+     * Check whether the 'before' value is before the 'to' value
+     * */
+    private rangeValidator;
+    /**
+     * The form control validator for the range when required.
+     * Check whether the 'before' and 'to' values are present
+     * */
+    private requiredRangeValidator;
+    /** The combined form control validator for this input. */
+    private validator;
+    /** Emits when the value changes (either due to user input or programmatic change). */
+    valueChange: EventEmitter<T | T[]>;
+    /** Emits when the disabled state has changed */
+    disabledChange: EventEmitter<boolean>;
+    get owlDateTimeInputAriaHaspopup(): boolean;
+    get owlDateTimeInputAriaOwns(): string;
+    get minIso8601(): string;
+    get maxIso8601(): string;
+    get owlDateTimeInputDisabled(): boolean;
+    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): {
+        [key: string]: any;
+    };
+    registerOnValidatorChange(fn: () => void): void;
+    /**
+     * Open the picker when user hold alt + DOWN_ARROW
+     * */
+    handleKeydownOnHost(event: KeyboardEvent): void;
+    handleBlurOnHost(event: Event): void;
+    handleInputOnHost(event: any): void;
+    handleChangeOnHost(event: any): void;
+    /**
+     * Set the native input property 'value'
+     */
+    formatNativeInputValue(): void;
+    /**
+     * Register the relationship between this input and its picker component
+     */
+    private registerDateTimePicker;
+    /**
+     * 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<OwlDateTimeInputDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OwlDateTimeInputDirective<any>, "input[owlDateTime]", ["owlDateTimeInput"], { "required": { "alias": "required"; "required": false; }; "owlDateTime": { "alias": "owlDateTime"; "required": false; }; "owlDateTimeFilter": { "alias": "owlDateTimeFilter"; "required": false; }; "_disabled": { "alias": "_disabled"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "selectMode": { "alias": "selectMode"; "required": false; }; "rangeSeparator": { "alias": "rangeSeparator"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; }; "values": { "alias": "values"; "required": false; }; }, { "_disabled": "_disabledChange"; "dateTimeChange": "dateTimeChange"; "dateTimeInput": "dateTimeInput"; }, never, never, true, never>;
+}
+
+declare class OwlDateTimeComponent<T> extends OwlDateTime<T> implements OnInit, OnDestroy {
+    overlay: Overlay;
+    private viewContainerRef;
+    private dialogService;
+    private injector;
+    protected changeDetector: ChangeDetectorRef;
+    private document;
+    /** Custom class for the picker backdrop. */
+    readonly backdropClass: _angular_core.InputSignal<string | string[]>;
+    /** Custom class for the picker overlay pane. */
+    readonly panelClass: _angular_core.InputSignal<string | string[]>;
+    /** The date to open the calendar to initially. */
+    private _startAt;
+    get startAt(): T | null;
+    set startAt(date: T | null);
+    /** The end date to set for range calendar. */
+    private _endAt;
+    get endAt(): T | null;
+    set endAt(date: T | null);
+    /**
+     * Set the type of the dateTime picker
+     *      'both' -- show both calendar and timer
+     *      'calendar' -- show only calendar
+     *      'timer' -- show only timer
+     */
+    private _pickerType;
+    get pickerType(): PickerType;
+    set pickerType(val: PickerType);
+    /**
+     * Whether the picker open as a dialog
+     */
+    _pickerMode: PickerMode;
+    get pickerMode(): PickerMode;
+    set pickerMode(mode: PickerMode);
+    /** Whether the date time picker should be disabled. */
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** Whether the calendar is open. */
+    private _opened;
+    get opened(): boolean;
+    set opened(val: boolean);
+    /**
+     * The scroll strategy when the picker is open
+     * Learn more this from https://material.angular.io/cdk/overlay/overview#scroll-strategies
+     * */
+    readonly scrollStrategy: _angular_core.InputSignal<ScrollStrategy>;
+    /**
+     * Callback when the picker is closed
+     * */
+    readonly afterPickerClosed: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Callback before the picker is open
+     * */
+    readonly beforePickerOpen: _angular_core.OutputEmitterRef<any>;
+    /**
+     * Callback when the picker is open
+     * */
+    readonly afterPickerOpen: _angular_core.OutputEmitterRef<any>;
+    /**
+     * 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 selected date
+     * */
+    readonly dateSelected: _angular_core.OutputEmitterRef<T>;
+    /**
+     * Emit when the selected value has been confirmed
+     * */
+    confirmSelectedChange: EventEmitter<T | T[]>;
+    /**
+     * Emits when the date time picker is disabled.
+     * */
+    disabledChange: EventEmitter<boolean>;
+    private pickerContainerPortal;
+    private pickerContainer;
+    private popupRef;
+    private dialogRef;
+    private dtInputSub;
+    private hidePickerStreamSub;
+    private confirmSelectedStreamSub;
+    private pickerOpenedStreamSub;
+    private pickerBeforeOpenedStreamSub;
+    private dialogEventsSub;
+    /** Pending async close (focus-restore path); cleared on destroy. */
+    private closeTimer;
+    /** The element that was focused before the date time picker was opened. */
+    private focusedElementBeforeOpen;
+    private _dtInput;
+    get dtInput(): OwlDateTimeInputDirective<T>;
+    private _selected;
+    get selected(): T | null;
+    set selected(value: T | null);
+    private _selecteds;
+    get selecteds(): T[];
+    set selecteds(values: T[]);
+    /** The minimum selectable date. */
+    get minDateTime(): T | null;
+    /** The maximum selectable date. */
+    get maxDateTime(): T | null;
+    get dateTimeFilter(): (date: T | null) => boolean;
+    get selectMode(): SelectMode;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    private readonly defaultScrollStrategy;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    registerInput(input: OwlDateTimeInputDirective<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;
+    /**
+     * Emits the selected date
+     * */
+    selectDate(normalizedDate: T): void;
+    /**
+     * Hide the picker
+     */
+    close(): void;
+    /**
+     * Release the overlay/dialog and the container stream subscriptions. Shared
+     * by close() and ngOnDestroy(); does not emit any lifecycle event itself.
+     */
+    private disposeOverlayResources;
+    /**
+     * 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<OwlDateTimeComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlDateTimeComponent<any>, "owl-date-time", ["owlDateTime"], { "backdropClass": { "alias": "backdropClass"; "required": false; "isSignal": true; }; "panelClass": { "alias": "panelClass"; "required": false; "isSignal": true; }; "startAt": { "alias": "startAt"; "required": false; }; "endAt": { "alias": "endAt"; "required": false; }; "pickerType": { "alias": "pickerType"; "required": false; }; "pickerMode": { "alias": "pickerMode"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "scrollStrategy": { "alias": "scrollStrategy"; "required": false; "isSignal": true; }; }, { "afterPickerClosed": "afterPickerClosed"; "beforePickerOpen": "beforePickerOpen"; "afterPickerOpen": "afterPickerOpen"; "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; "dateSelected": "dateSelected"; }, never, never, true, never>;
+}
+
+declare class OwlDateTimeTriggerDirective<T> implements OnInit, OnChanges, AfterContentInit, OnDestroy {
+    protected changeDetector: ChangeDetectorRef;
+    readonly dtPicker: _angular_core.InputSignal<OwlDateTimeComponent<T>>;
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    get owlDTTriggerDisabledClass(): boolean;
+    private stateChanges;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    handleClickOnHost(event: Event): void;
+    private watchStateChanges;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDateTimeTriggerDirective<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<OwlDateTimeTriggerDirective<any>, "[owlDateTimeTrigger]", never, { "dtPicker": { "alias": "owlDateTimeTrigger"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class OwlCalendarComponent<T> implements OnInit, AfterContentInit, AfterViewChecked, OnDestroy {
+    private elmRef;
+    private pickerIntl;
+    private injector;
+    private cdRef;
+    private dateTimeAdapter;
+    private dateTimeFormats;
+    DateView: typeof DateView;
+    get minDate(): T | null;
+    set minDate(value: T | null);
+    get maxDate(): T | null;
+    set maxDate(value: T | null);
+    get pickerMoment(): T;
+    set pickerMoment(value: T);
+    get selected(): T | null;
+    set selected(value: T | null);
+    get selecteds(): T[];
+    set selecteds(values: T[]);
+    get periodButtonText(): string;
+    get periodButtonLabel(): string;
+    get prevButtonLabel(): string;
+    get nextButtonLabel(): string;
+    get currentView(): DateViewType;
+    set currentView(view: DateViewType);
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    get showControlArrows(): boolean;
+    get isMonthView(): boolean;
+    /**
+     * Bind class 'owl-dt-calendar' to host
+     * */
+    get owlDTCalendarClass(): boolean;
+    constructor();
+    /**
+     * Date filter for the month and year view
+     * */
+    readonly dateFilter: _angular_core.InputSignal<(date: T) => boolean>;
+    /**
+     * Set the first day of week
+     */
+    readonly firstDayOfWeek: _angular_core.InputSignal<number>;
+    /** The minimum selectable date. */
+    private _minDate;
+    /** The maximum selectable date. */
+    private _maxDate;
+    /** The current picker moment */
+    private _pickerMoment;
+    readonly selectMode: _angular_core.InputSignal<SelectMode>;
+    /** The currently selected moment. */
+    private _selected;
+    private _selecteds;
+    /**
+     * The view that the calendar should start in.
+     */
+    readonly startView: _angular_core.InputSignal<DateViewType>;
+    /**
+     * Whether to should only the year and multi-year views.
+     */
+    readonly yearOnly: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to show calendar weeks in the calendar
+     * */
+    readonly showCalendarWeeks: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to should only the multi-year view.
+     */
+    readonly multiyearOnly: _angular_core.InputSignal<boolean>;
+    /**
+     * 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 selected date changes. */
+    readonly dateClicked: _angular_core.OutputEmitterRef<T>;
+    /** Emits when the currently selected date changes. */
+    readonly selectedChange: _angular_core.OutputEmitterRef<T>;
+    /** 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>;
+    private _currentView;
+    private intlChangesSub;
+    /**
+     * Used for scheduling that focus should be moved to the active cell on the next tick.
+     * We need to schedule it, rather than do it immediately, because we have to wait
+     * for Angular to re-evaluate the view children.
+     */
+    private moveFocusOnNextTick;
+    /**
+     * Date filter for the month and year view
+     */
+    dateFilterForViews: (date: T) => boolean;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /**
+     * 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: DateViewType): 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<OwlCalendarComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlCalendarComponent<any>, "owl-date-time-calendar", ["owlDateTimeCalendar"], { "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "pickerMoment": { "alias": "pickerMoment"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selecteds": { "alias": "selecteds"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; "startView": { "alias": "startView"; "required": false; "isSignal": true; }; "yearOnly": { "alias": "yearOnly"; "required": false; "isSignal": true; }; "showCalendarWeeks": { "alias": "showCalendarWeeks"; "required": false; "isSignal": true; }; "multiyearOnly": { "alias": "multiyearOnly"; "required": false; "isSignal": true; }; "hideOtherMonths": { "alias": "hideOtherMonths"; "required": false; "isSignal": true; }; }, { "pickerMomentChange": "pickerMomentChange"; "dateClicked": "dateClicked"; "selectedChange": "selectedChange"; "userSelection": "userSelection"; "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; }, never, never, true, never>;
+}
+
+declare class OwlTimerComponent<T> implements OnInit {
+    private injector;
+    private elmRef;
+    private pickerIntl;
+    private cdRef;
+    private dateTimeAdapter;
+    /** The current picker moment */
+    private _pickerMoment;
+    get pickerMoment(): T;
+    set pickerMoment(value: T);
+    /** The minimum selectable date time. */
+    private _minDateTime;
+    get minDateTime(): T | null;
+    set minDateTime(value: T | null);
+    /** The maximum selectable date time. */
+    private _maxDateTime;
+    get maxDateTime(): T | null;
+    set maxDateTime(value: T | null);
+    private isPM;
+    /**
+     * 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>;
+    get hourValue(): number;
+    /**
+     * 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.
+     * */
+    get hourBoxValue(): number;
+    get minuteValue(): number;
+    get secondValue(): number;
+    get upHourButtonLabel(): string;
+    get downHourButtonLabel(): string;
+    get upMinuteButtonLabel(): string;
+    get downMinuteButtonLabel(): string;
+    get upSecondButtonLabel(): string;
+    get downSecondButtonLabel(): string;
+    get hour12ButtonLabel(): string;
+    readonly selectedChange: _angular_core.OutputEmitterRef<T>;
+    get owlDTTimerClass(): boolean;
+    get owlDTTimeTabIndex(): number;
+    ngOnInit(): void;
+    /**
+     * 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
+     */
+    upHourEnabled(): boolean;
+    /**
+     * Check if the down hour button is enabled
+     */
+    downHourEnabled(): boolean;
+    /**
+     * Check if the up minute button is enabled
+     */
+    upMinuteEnabled(): boolean;
+    /**
+     * Check if the down minute button is enabled
+     */
+    downMinuteEnabled(): boolean;
+    /**
+     * Check if the up second button is enabled
+     */
+    upSecondEnabled(): boolean;
+    /**
+     * Check if the down second button is enabled
+     */
+    downSecondEnabled(): 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<OwlTimerComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlTimerComponent<any>, "owl-date-time-timer", ["owlDateTimeTimer"], { "pickerMoment": { "alias": "pickerMoment"; "required": false; }; "minDateTime": { "alias": "minDateTime"; "required": false; }; "maxDateTime": { "alias": "maxDateTime"; "required": false; }; "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>;
+}
+
+declare class OwlDateTimeContainerComponent<T> implements OnInit, AfterContentInit, AfterViewInit, OnDestroy {
+    private cdRef;
+    private elmRef;
+    private pickerIntl;
+    private dateTimeAdapter;
+    readonly calendar: _angular_core.Signal<OwlCalendarComponent<any>>;
+    readonly timer: _angular_core.Signal<OwlTimerComponent<any>>;
+    picker: OwlDateTime<T>;
+    activeSelectedIndex: number;
+    /** Emits when an animation state changes. */
+    animationStateChanged: EventEmitter<IDateTimePickerAnimationEvent>;
+    private retainStartTime;
+    private retainEndTime;
+    /**
+     * Stream emits when try to hide picker
+     * */
+    private hidePicker$;
+    get hidePickerStream(): Observable<any>;
+    /**
+     * Stream emits when try to confirm the selected value
+     * */
+    private confirmSelected$;
+    get confirmSelectedStream(): Observable<any>;
+    private beforePickerOpened$;
+    get beforePickerOpenedStream(): Observable<any>;
+    private pickerOpened$;
+    get pickerOpenedStream(): Observable<any>;
+    /**
+     * The current picker moment. This determines which time period is shown and which date is
+     * highlighted when using keyboard navigation.
+     */
+    private _clamPickerMoment;
+    get pickerMoment(): T;
+    set pickerMoment(value: T);
+    get pickerType(): PickerType;
+    get cancelLabel(): string;
+    get setLabel(): string;
+    /**
+     * The range 'from' label
+     * */
+    get fromLabel(): string;
+    /**
+     * The range 'to' label
+     * */
+    get toLabel(): string;
+    /**
+     * The range 'from' formatted value
+     * */
+    get fromFormattedValue(): string;
+    /**
+     * The range 'to' formatted value
+     * */
+    get toFormattedValue(): string;
+    /**
+     * Cases in which the control buttons show in the picker
+     * 1) picker mode is 'dialog'
+     * 2) picker type is NOT 'calendar' and the picker mode is NOT 'inline'
+     * */
+    get showControlButtons(): boolean;
+    get containerElm(): HTMLElement;
+    get owlDTContainerClass(): boolean;
+    get owlDTPopupContainerClass(): boolean;
+    get owlDTDialogContainerClass(): boolean;
+    get owlDTInlineContainerClass(): boolean;
+    get owlDTContainerDisabledClass(): boolean;
+    get owlDTContainerId(): string;
+    get owlDTContainerAnimation(): any;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    handleContainerAnimationStart(animationName: 'enter' | 'leave'): void;
+    handleContainerAnimationDone(animationName: 'enter' | 'leave'): void;
+    dateSelected(date: T): void;
+    timeSelected(time: T): void;
+    /**
+     * Handle click on cancel button
+     */
+    onCancelClicked(event: any): void;
+    /**
+     * Handle click on set button
+     */
+    onSetClicked(event: any): void;
+    /**
+     * Handle click on inform radio group
+     */
+    handleClickOnInfoGroup(event: any, index: number): void;
+    /**
+     * Handle click on inform radio group
+     */
+    handleKeydownOnInfoGroup(event: any, next: any, index: number): void;
+    protected onAnimateEnter(event: AnimationCallbackEvent): void;
+    protected onAnimateLeave(event: AnimationCallbackEvent): void;
+    /**
+     * Set the value of activeSelectedIndex
+     */
+    private setActiveSelectedIndex;
+    private initPicker;
+    /**
+     * Select calendar date in single mode,
+     * it returns null when date is not selected.
+     */
+    private dateSelectedInSingleMode;
+    /**
+     * Select dates in range Mode
+     */
+    private dateSelectedInRangeMode;
+    /**
+     * Update the given calendar date's time and check if it is valid
+     * Because the calendar date has 00:00:00 as default time, if the picker type is 'both',
+     * we need to update the given calendar date's time before selecting it.
+     * if it is valid, return the updated dateTime
+     * if it is not valid, return null
+     */
+    private updateAndCheckCalendarDate;
+    /**
+     * Focus to the picker
+     * */
+    private focusPicker;
+    private parseCssVariableDuration;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDateTimeContainerComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlDateTimeContainerComponent<any>, "owl-date-time-container", ["owlDateTimeContainer"], {}, {}, 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 OwlCalendarBodyComponent implements OnInit {
+    private elmRef;
+    private injector;
+    /**
+     * The cell number of the active cell in the table.
+     */
+    readonly activeCell: _angular_core.InputSignal<number>;
+    /**
+     * The cells to display in the table.
+     * */
+    readonly rows: _angular_core.InputSignal<CalendarCell[][]>;
+    /**
+     * The number of columns in the table.
+     * */
+    readonly numCols: _angular_core.InputSignal<number>;
+    /**
+     * The ratio (width / height) to use for the cells in the table.
+     */
+    readonly cellRatio: _angular_core.InputSignal<number>;
+    /**
+     * The value in the table that corresponds to today.
+     * */
+    readonly todayValue: _angular_core.InputSignal<number>;
+    /**
+     * The value in the table that is currently selected.
+     * */
+    readonly selectedValues: _angular_core.InputSignal<number[]>;
+    /**
+     * Current picker select mode
+     */
+    readonly selectMode: _angular_core.InputSignal<SelectMode>;
+    /**
+     * Emit when a calendar cell is selected
+     * */
+    readonly select: _angular_core.OutputEmitterRef<CalendarCell>;
+    get owlDTCalendarBodyClass(): boolean;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    ngOnInit(): void;
+    selectCell(cell: CalendarCell): void;
+    isActiveCell(rowIndex: number, colIndex: number): boolean;
+    /**
+     * Check if the cell is selected
+     */
+    isSelected(value: number): boolean;
+    /**
+     * Check if the cell in the range
+     * */
+    isInRange(value: number): boolean;
+    /**
+     * Check if the cell is the range from
+     * */
+    isRangeFrom(value: number): boolean;
+    /**
+     * Check if the cell is the range to
+     * */
+    isRangeTo(value: number): boolean;
+    /**
+     * Focus to a active cell
+     * */
+    focusActiveCell(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlCalendarBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlCalendarBodyComponent, "[owl-date-time-calendar-body]", ["owlDateTimeCalendarBody"], { "activeCell": { "alias": "activeCell"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "numCols": { "alias": "numCols"; "required": false; "isSignal": true; }; "cellRatio": { "alias": "cellRatio"; "required": false; "isSignal": true; }; "todayValue": { "alias": "todayValue"; "required": false; "isSignal": true; }; "selectedValues": { "alias": "selectedValues"; "required": false; "isSignal": true; }; "selectMode": { "alias": "selectMode"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
+declare class OwlMultiYearViewComponent<T> implements OnInit, AfterContentInit {
+    private cdRef;
+    private pickerIntl;
+    private dateTimeAdapter;
+    private options;
+    /**
+     * The select mode of the picker;
+     * */
+    private _selectMode;
+    get selectMode(): SelectMode;
+    set selectMode(val: SelectMode);
+    /** The currently selected date. */
+    private _selected;
+    get selected(): T | null;
+    set selected(value: T | null);
+    private _selecteds;
+    get selecteds(): T[];
+    set selecteds(values: T[]);
+    private _pickerMoment;
+    get pickerMoment(): T;
+    set pickerMoment(value: T);
+    /**
+     * A function used to filter which dates are selectable
+     * */
+    private _dateFilter;
+    get dateFilter(): (date: T) => boolean;
+    set dateFilter(filter: (date: T) => boolean);
+    /** The minimum selectable date. */
+    private _minDate;
+    get minDate(): T | null;
+    set minDate(value: T | null);
+    /** The maximum selectable date. */
+    private _maxDate;
+    get maxDate(): T | null;
+    set maxDate(value: T | null);
+    private _todayYear;
+    get todayYear(): number;
+    private _years;
+    get years(): CalendarCell[][];
+    private _selectedYears;
+    get selectedYears(): number[];
+    private initiated;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    get activeCell(): number;
+    get tableHeader(): string;
+    get prevButtonLabel(): string;
+    get nextButtonLabel(): 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 */
+    readonly calendarBodyElm: _angular_core.Signal<OwlCalendarBodyComponent>;
+    get owlDTCalendarView(): boolean;
+    get owlDTCalendarMultiYearView(): boolean;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    /**
+     * 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;
+    generateYearList(): 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;
+    private setSelectedYears;
+    /** Whether the given year is enabled. */
+    private isYearEnabled;
+    private isSameYearList;
+    /**
+     * Get a valid date object
+     */
+    private getValidDate;
+    private focusActiveCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlMultiYearViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlMultiYearViewComponent<any>, "owl-date-time-multi-year-view", never, { "selectMode": { "alias": "selectMode"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selecteds": { "alias": "selecteds"; "required": false; }; "pickerMoment": { "alias": "pickerMoment"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "change": "change"; "yearSelected": "yearSelected"; "pickerMomentChange": "pickerMomentChange"; "keyboardEnter": "keyboardEnter"; }, never, never, true, never>;
+}
+
+declare class OwlYearViewComponent<T> implements OnInit, AfterContentInit, OnDestroy {
+    private cdRef;
+    private dateTimeAdapter;
+    private dateTimeFormats;
+    /**
+     * The select mode of the picker;
+     * */
+    private _selectMode;
+    get selectMode(): SelectMode;
+    set selectMode(val: SelectMode);
+    /** The currently selected date. */
+    private _selected;
+    get selected(): T | null;
+    set selected(value: T | null);
+    private _selecteds;
+    get selecteds(): T[];
+    set selecteds(values: T[]);
+    private _pickerMoment;
+    get pickerMoment(): T;
+    set pickerMoment(value: T);
+    /**
+     * A function used to filter which dates are selectable
+     * */
+    private _dateFilter;
+    get dateFilter(): (date: T) => boolean;
+    set dateFilter(filter: (date: T) => boolean);
+    /** The minimum selectable date. */
+    private _minDate;
+    get minDate(): T | null;
+    set minDate(value: T | null);
+    /** The maximum selectable date. */
+    private _maxDate;
+    get maxDate(): T | null;
+    set maxDate(value: T | null);
+    private readonly monthNames;
+    private _months;
+    get months(): CalendarCell[][];
+    get activeCell(): number;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    private localeSub;
+    private initiated;
+    todayMonth: number | null;
+    /**
+     * An array to hold all selectedDates' month value
+     * the value is the month number in current year
+     * */
+    selectedMonths: number[];
+    /**
+     * 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 */
+    readonly calendarBodyElm: _angular_core.Signal<OwlCalendarBodyComponent>;
+    get owlDTCalendarView(): boolean;
+    constructor();
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * 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;
+    /**
+     * Generate the calendar month list
+     * */
+    private generateMonthList;
+    /**
+     * 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 null if the given Date is in another year.
+     */
+    private getMonthInCurrentYear;
+    /**
+     * Set the selectedMonths value
+     * In single mode, it has only one value which represent the month the selected date in
+     * In range mode, it would has two values, one for the month the fromValue in and the other for the month the toValue in
+     * */
+    private setSelectedMonths;
+    /**
+     * 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<OwlYearViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlYearViewComponent<any>, "owl-date-time-year-view", ["owlMonthView"], { "selectMode": { "alias": "selectMode"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selecteds": { "alias": "selecteds"; "required": false; }; "pickerMoment": { "alias": "pickerMoment"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "change": "change"; "monthSelected": "monthSelected"; "pickerMomentChange": "pickerMomentChange"; "keyboardEnter": "keyboardEnter"; }, never, never, true, never>;
+}
+
+declare class OwlMonthViewComponent<T> implements OnInit, AfterContentInit, OnDestroy {
+    private cdRef;
+    private dateTimeAdapter;
+    private dateTimeFormats;
+    /**
+     * Whether to hide dates in other months at the start or end of the current month.
+     * */
+    readonly hideOtherMonths: _angular_core.InputSignal<boolean>;
+    /**
+     * Whether to show calendar weeks in the calendar
+     * */
+    readonly showCalendarWeeks: _angular_core.InputSignal<boolean>;
+    private isDefaultFirstDayOfWeek;
+    /**
+     * Define the first day of a week
+     * Sunday: 0 - Saturday: 6
+     * */
+    private _firstDayOfWeek;
+    get firstDayOfWeek(): number;
+    set firstDayOfWeek(val: number);
+    /**
+     * The select mode of the picker;
+     * */
+    private _selectMode;
+    get selectMode(): SelectMode;
+    set selectMode(val: SelectMode);
+    /** The currently selected date. */
+    private _selected;
+    get selected(): T | null;
+    set selected(value: T | null);
+    private _selecteds;
+    get selecteds(): T[];
+    set selecteds(values: T[]);
+    private _pickerMoment;
+    get pickerMoment(): T;
+    set pickerMoment(value: T);
+    /**
+     * A function used to filter which dates are selectable
+     * */
+    private _dateFilter;
+    get dateFilter(): (date: T) => boolean;
+    set dateFilter(filter: (date: T) => boolean);
+    /** The minimum selectable date. */
+    private _minDate;
+    get minDate(): T | null;
+    set minDate(value: T | null);
+    /** The maximum selectable date. */
+    private _maxDate;
+    get maxDate(): T | null;
+    set maxDate(value: T | null);
+    private _weekdays;
+    get weekdays(): {
+        long: string;
+        short: string;
+        narrow: string;
+    }[];
+    private _days;
+    get days(): CalendarCell[][];
+    get activeCell(): number;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    private firstDateOfMonth;
+    private localeSub;
+    private initiated;
+    private dateNames;
+    /**
+     * The date of the month that today falls on.
+     * */
+    todayDate: number | null;
+    /**
+     * Week day numbers
+     * */
+    weekNumbers: number[];
+    /**
+     * An array to hold all selectedDates' value
+     * the value is the day number in current month
+     * */
+    selectedDates: number[];
+    firstRowOffset: number;
+    /**
+     * Callback to invoke when a new date is selected
+     * */
+    readonly selectedChange: _angular_core.OutputEmitterRef<T>;
+    /**
+     * 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 */
+    readonly calendarBodyElm: _angular_core.Signal<OwlCalendarBodyComponent>;
+    get owlDTCalendarView(): boolean;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * 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;
+    /**
+     * Generate the calendar weekdays array
+     * */
+    private generateWeekDays;
+    /**
+     * Generate the calendar days array
+     * */
+    private generateCalendar;
+    getISOWeek(d: Date): number;
+    private updateFirstDayOfWeek;
+    /**
+     * 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 none-null and in the same month
+     */
+    isSameMonth(dateLeft: T, dateRight: T): boolean;
+    /**
+     * Set the selectedDates value.
+     * In single mode, it has only one value which represent the selected date
+     * In range mode, it would has two values, one for the fromValue and the other for the toValue
+     * */
+    private setSelectedDates;
+    private focusActiveCell;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlMonthViewComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlMonthViewComponent<any>, "owl-date-time-month-view", ["owlYearView"], { "hideOtherMonths": { "alias": "hideOtherMonths"; "required": false; "isSignal": true; }; "showCalendarWeeks": { "alias": "showCalendarWeeks"; "required": false; "isSignal": true; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "selectMode": { "alias": "selectMode"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "selecteds": { "alias": "selecteds"; "required": false; }; "pickerMoment": { "alias": "pickerMoment"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "selectedChange": "selectedChange"; "userSelection": "userSelection"; "pickerMomentChange": "pickerMomentChange"; }, never, never, true, never>;
+}
+
+declare class OwlTimerBoxComponent implements OnInit, OnDestroy {
+    readonly showDivider: _angular_core.InputSignal<boolean>;
+    readonly upBtnAriaLabel: _angular_core.InputSignal<string>;
+    readonly upBtnDisabled: _angular_core.InputSignal<boolean>;
+    readonly downBtnAriaLabel: _angular_core.InputSignal<string>;
+    readonly downBtnDisabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Value would be displayed in the box
+     * If it is null, the box would display [value]
+     * */
+    readonly boxValue: _angular_core.InputSignal<number>;
+    readonly value: _angular_core.InputSignal<number>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly inputLabel: _angular_core.InputSignal<string>;
+    readonly valueChange: _angular_core.OutputEmitterRef<number>;
+    readonly inputChange: _angular_core.OutputEmitterRef<number>;
+    private inputStream;
+    private inputStreamSub;
+    private hasFocus;
+    get displayValue(): string;
+    get owlDTTimerBoxClass(): boolean;
+    private readonly valueInput;
+    private onValueInputMouseWheelBind;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    upBtnClicked(): void;
+    downBtnClicked(): void;
+    handleInputChange(val: string): void;
+    focusIn(): void;
+    focusOut(value: string): void;
+    private updateValue;
+    private updateValueViaInput;
+    private onValueInputMouseWheel;
+    private bindValueInputMouseWheel;
+    private unbindValueInputMouseWheel;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlTimerBoxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlTimerBoxComponent, "owl-date-time-timer-box", ["owlDateTimeTimerBox"], { "showDivider": { "alias": "showDivider"; "required": false; "isSignal": true; }; "upBtnAriaLabel": { "alias": "upBtnAriaLabel"; "required": false; "isSignal": true; }; "upBtnDisabled": { "alias": "upBtnDisabled"; "required": false; "isSignal": true; }; "downBtnAriaLabel": { "alias": "downBtnAriaLabel"; "required": false; "isSignal": true; }; "downBtnDisabled": { "alias": "downBtnDisabled"; "required": false; "isSignal": true; }; "boxValue": { "alias": "boxValue"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "inputLabel": { "alias": "inputLabel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "inputChange": "inputChange"; }, never, never, true, never>;
+}
+
+declare class OwlHourInputComponent implements ControlValueAccessor {
+    private readonly pickerIntl;
+    readonly upBtnAriaLabel: _angular_core.InputSignal<string>;
+    readonly downBtnAriaLabel: _angular_core.InputSignal<string>;
+    readonly min: _angular_core.InputSignal<number>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly hour12Timer: _angular_core.InputSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<number>;
+    readonly disabled: _angular_core.ModelSignal<boolean>;
+    protected readonly isPM: _angular_core.Signal<boolean>;
+    protected readonly hour12ButtonLabel: _angular_core.Signal<string>;
+    protected readonly boxValue: _angular_core.Signal<number>;
+    get owlHourInputClass(): boolean;
+    upBtnClicked(): void;
+    downBtnClicked(): void;
+    setValueViaInput(hours: number): void;
+    setValue(hours: number): void;
+    setMeridian(): void;
+    /**
+     * Update the value (which emits `valueChange` through the model) and notify
+     * the forms API, mirroring the behaviour of the old value setter.
+     */
+    private commitValue;
+    onChange: any;
+    onTouch: any;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlHourInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlHourInputComponent, "owl-hour-input", ["owlHourInput"], { "upBtnAriaLabel": { "alias": "upBtnAriaLabel"; "required": false; "isSignal": true; }; "downBtnAriaLabel": { "alias": "downBtnAriaLabel"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "hour12Timer": { "alias": "hour12Timer"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "disabled": "disabledChange"; }, never, never, true, never>;
+}
+
+/**
+ * numberFixedLen.pipe
+ */
+
+declare class NumberFixedLenPipe implements PipeTransform {
+    transform(num: number, len: number): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberFixedLenPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<NumberFixedLenPipe, "numberFixedLen", true>;
+}
+
+declare class OwlDateTimeInlineComponent<T> extends OwlDateTime<T> implements OnInit, ControlValueAccessor {
+    protected changeDetector: ChangeDetectorRef;
+    readonly container: _angular_core.Signal<OwlDateTimeContainerComponent<any>>;
+    /**
+     * Set the type of the dateTime picker
+     *      'both' -- show both calendar and timer
+     *      'calendar' -- show only calendar
+     *      'timer' -- show only timer
+     */
+    private _pickerType;
+    get pickerType(): PickerType;
+    set pickerType(val: PickerType);
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _selectMode;
+    get selectMode(): SelectMode;
+    set selectMode(mode: SelectMode);
+    /** The date to open the calendar to initially. */
+    private _startAt;
+    get startAt(): T | null;
+    set startAt(date: T | null);
+    /** The date to open for range calendar. */
+    private _endAt;
+    get endAt(): T | null;
+    set endAt(date: T | null);
+    private _dateTimeFilter;
+    get dateTimeFilter(): (date: T | null) => boolean;
+    set dateTimeFilter(filter: (date: T | null) => boolean);
+    /** The minimum valid date. */
+    private _min;
+    get minDateTime(): T | null;
+    set minDateTime(value: T | null);
+    /** The maximum valid date. */
+    private _max;
+    get maxDateTime(): T | null;
+    set maxDateTime(value: T | null);
+    private _value;
+    get value(): T | null;
+    set value(value: T | null);
+    private _values;
+    get values(): T[];
+    set values(values: T[]);
+    /**
+     * 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 selected date
+     * */
+    readonly dateSelected: _angular_core.OutputEmitterRef<T>;
+    private _selected;
+    get selected(): T | null;
+    set selected(value: T | null);
+    private _selecteds;
+    get selecteds(): T[];
+    set selecteds(values: T[]);
+    get opened(): boolean;
+    get pickerMode(): PickerMode;
+    get isInSingleMode(): boolean;
+    get isInRangeMode(): boolean;
+    get owlDTInlineClass(): boolean;
+    private onModelChange;
+    private onModelTouched;
+    constructor();
+    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;
+    /**
+     * Emits the selected date
+     * */
+    selectDate(normalizedDate: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDateTimeInlineComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OwlDateTimeInlineComponent<any>, "owl-date-time-inline", never, { "pickerType": { "alias": "pickerType"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selectMode": { "alias": "selectMode"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "endAt": { "alias": "endAt"; "required": false; }; "dateTimeFilter": { "alias": "owlDateTimeFilter"; "required": false; }; "minDateTime": { "alias": "min"; "required": false; }; "maxDateTime": { "alias": "max"; "required": false; }; "value": { "alias": "value"; "required": false; }; "values": { "alias": "values"; "required": false; }; }, { "yearSelected": "yearSelected"; "monthSelected": "monthSelected"; "dateSelected": "dateSelected"; }, never, never, true, never>;
+}
+
+/**
+ * @deprecated Use `provideOwlDateTime()` instead. This module will be removed in v21.0.0.
+ *
+ * Migration guide:
+ * ```typescript
+ * // Before (NgModule approach):
+ * import { OwlDateTimeModule, OwlNativeDateTimeModule } from '@dintecom/ngx-datetime-picker';
+ *
+ * @NgModule({
+ *   imports: [OwlDateTimeModule, OwlNativeDateTimeModule]
+ * })
+ * export class AppModule { }
+ *
+ * // After (Standalone/Provider approach):
+ * import { provideOwlDateTime, provideOwlNativeDateTime } from '@dintecom/ngx-datetime-picker';
+ *
+ * // For standalone app:
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlNativeDateTime()
+ *   ]
+ * });
+ *
+ * // For existing NgModule app:
+ * @NgModule({
+ *   providers: [
+ *     provideOwlDateTime(),
+ *     provideOwlNativeDateTime()
+ *   ]
+ * })
+ * export class AppModule { }
+ * ```
+ */
+declare class OwlDateTimeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDateTimeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<OwlDateTimeModule, never, [typeof i1.CommonModule, typeof i3.OverlayModule, typeof OwlDialogModule, typeof i2.A11yModule, typeof OwlDateTimeTriggerDirective, typeof OwlDateTimeInputDirective, typeof OwlDateTimeComponent, typeof OwlDateTimeContainerComponent, typeof OwlMultiYearViewComponent, typeof OwlYearViewComponent, typeof OwlMonthViewComponent, typeof OwlTimerComponent, typeof OwlTimerBoxComponent, typeof OwlHourInputComponent, typeof OwlCalendarComponent, typeof OwlCalendarBodyComponent, typeof NumberFixedLenPipe, typeof OwlDateTimeInlineComponent], [typeof OwlCalendarComponent, typeof OwlTimerComponent, typeof OwlTimerBoxComponent, typeof OwlHourInputComponent, typeof OwlDateTimeTriggerDirective, typeof OwlDateTimeInputDirective, typeof OwlDateTimeComponent, typeof OwlDateTimeInlineComponent, typeof OwlMultiYearViewComponent, typeof OwlYearViewComponent, typeof OwlMonthViewComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<OwlDateTimeModule>;
+}
+
+/**
+ * @deprecated Use `provideOwlNativeDateTime()` instead. This module will be removed in v21.0.0.
+ * @see provideOwlNativeDateTime
+ */
+declare class NativeDateTimeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeDateTimeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<NativeDateTimeModule, never, [typeof i1$1.PlatformModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NativeDateTimeModule>;
+}
+/**
+ * @deprecated Use `provideOwlNativeDateTime()` instead. This module will be removed in v21.0.0.
+ *
+ * Migration guide:
+ * ```typescript
+ * // Before:
+ * import { OwlNativeDateTimeModule } from '@dintecom/ngx-datetime-picker';
+ * @NgModule({ imports: [OwlNativeDateTimeModule] })
+ *
+ * // After:
+ * import { provideOwlNativeDateTime } from '@dintecom/ngx-datetime-picker';
+ * providers: [provideOwlNativeDateTime()]
+ * ```
+ */
+declare class OwlNativeDateTimeModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlNativeDateTimeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<OwlNativeDateTimeModule, never, [typeof NativeDateTimeModule], never>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<OwlNativeDateTimeModule>;
+}
+
+declare class OwlDateTimeIntl {
+    /**
+     * Stream that emits whenever the labels here are changed. Use this to notify
+     * components if the labels have changed after initialization.
+     */
+    readonly changes: Subject<void>;
+    /** A label for the up second button (used by screen readers).  */
+    upSecondLabel: string;
+    /** A label for the down second button (used by screen readers).  */
+    downSecondLabel: string;
+    /** A label for the up minute button (used by screen readers).  */
+    upMinuteLabel: string;
+    /** A label for the down minute button (used by screen readers).  */
+    downMinuteLabel: string;
+    /** A label for the up hour button (used by screen readers).  */
+    upHourLabel: string;
+    /** A label for the down hour button (used by screen readers).  */
+    downHourLabel: string;
+    /** A label for the previous month button (used by screen readers). */
+    prevMonthLabel: string;
+    /** A label for the next month button (used by screen readers). */
+    nextMonthLabel: string;
+    /** A label for the previous year button (used by screen readers). */
+    prevYearLabel: string;
+    /** A label for the next year button (used by screen readers). */
+    nextYearLabel: string;
+    /** A label for the previous multi-year button (used by screen readers). */
+    prevMultiYearLabel: string;
+    /** A label for the next multi-year button (used by screen readers). */
+    nextMultiYearLabel: string;
+    /** A label for the 'switch to month view' button (used by screen readers). */
+    switchToMonthViewLabel: string;
+    /** A label for the 'switch to year view' button (used by screen readers). */
+    switchToMultiYearViewLabel: string;
+    /** A label for the cancel button */
+    cancelBtnLabel: string;
+    /** A label for the set button */
+    setBtnLabel: string;
+    /** A label for the range 'from' in picker info */
+    rangeFromLabel: string;
+    /** A label for the range 'to' in picker info */
+    rangeToLabel: string;
+    /** A label for the hour12 button (AM) */
+    hour12AMLabel: string;
+    /** A label for the hour12 button (PM) */
+    hour12PMLabel: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OwlDateTimeIntl, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<OwlDateTimeIntl>;
+}
+
+declare class UnixTimestampDateTimeAdapter extends DateTimeAdapter<number> {
+    private owlDateTimeLocale;
+    firstMonthOfTheYear: number;
+    firstDayOfTheWeek: number;
+    constructor();
+    /** Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors. */
+    private readonly _clampDate;
+    /**
+     * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.
+     * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off
+     * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`
+     * will produce `'8/13/1800'`.
+     */
+    useUtcForDisplay: boolean;
+    /**
+     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
+     * other browsers do not. We remove them to make output consistent and because they interfere with
+     * date parsing.
+     */
+    private static search_ltr_rtl_pattern;
+    private static stripDirectionalityCharacters;
+    /**
+     * When converting Date object to string, javascript built-in functions may return wrong
+     * results because it applies its internal DST rules. The DST rules around the world change
+     * very frequently, and the current valid rule is not always valid in previous years though.
+     * We work around this problem building a new Date object which has its internal UTC
+     * representation with the local date and time.
+     */
+    private static _format;
+    addCalendarDays(date: number, amount: number): number;
+    addCalendarMonths(date: number, amount: number): number;
+    addCalendarYears(date: number, amount: number): number;
+    clone(date: number): number;
+    createDate(year: number, month: number, date: number, hours?: number, minutes?: number, seconds?: number): number;
+    differenceInCalendarDays(dateLeft: number, dateRight: number): number;
+    format(date: number, displayFormat: any): string;
+    getDate(date: number): number;
+    getDateNames(): string[];
+    getDay(date: number): number;
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getHours(date: number): number;
+    getMinutes(date: number): number;
+    getMonth(date: number): number;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getNumDaysInMonth(date: number): number;
+    getSeconds(date: number): number;
+    getTime(date: number): number;
+    getYear(date: number): number;
+    getYearName(date: number): string;
+    invalid(): number;
+    isDateInstance(obj: any): boolean;
+    isEqual(dateLeft: number, dateRight: number): boolean;
+    isSameDay(dateLeft: number, dateRight: number): boolean;
+    isValid(date: number): boolean;
+    now(): number;
+    parse(value: any, parseFormat: any): number | null;
+    setHours(date: number, amount: number): number;
+    setMinutes(date: number, amount: number): number;
+    setSeconds(date: number, amount: number): number;
+    toIso8601(date: number): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UnixTimestampDateTimeAdapter, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UnixTimestampDateTimeAdapter>;
+}
+
+/**
+ * unix-timestamp-date-time-format.class
+ */
+
+declare const OWL_UNIX_TIMESTAMP_DATE_TIME_FORMATS: OwlDateTimeFormats;
+
+declare class NativeDateTimeAdapter extends DateTimeAdapter<Date> {
+    private owlDateTimeLocale;
+    firstMonthOfTheYear: number;
+    firstDayOfTheWeek: number;
+    /** Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors. */
+    private readonly _clampDate;
+    /**
+     * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.
+     * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off
+     * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`
+     * will produce `'8/13/1800'`.
+     */
+    useUtcForDisplay: boolean;
+    constructor();
+    getYear(date: Date): number;
+    getMonth(date: Date): number;
+    getDay(date: Date): number;
+    getDate(date: Date): number;
+    getHours(date: Date): number;
+    getMinutes(date: Date): number;
+    getSeconds(date: Date): number;
+    getTime(date: Date): number;
+    getNumDaysInMonth(date: Date): number;
+    differenceInCalendarDays(dateLeft: Date, dateRight: Date): number;
+    getYearName(date: Date): string;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getDateNames(): string[];
+    toIso8601(date: Date): string;
+    isEqual(dateLeft: Date, dateRight: Date): boolean;
+    isSameDay(dateLeft: Date, dateRight: Date): boolean;
+    isValid(date: Date): boolean;
+    invalid(): Date;
+    isDateInstance(obj: any): boolean;
+    addCalendarYears(date: Date, amount: number): Date;
+    addCalendarMonths(date: Date, amount: number): Date;
+    addCalendarDays(date: Date, amount: number): Date;
+    setHours(date: Date, amount: number): Date;
+    setMinutes(date: Date, amount: number): Date;
+    setSeconds(date: Date, amount: number): Date;
+    createDate(year: number, month: number, date: number, hours?: number, minutes?: number, seconds?: number): Date;
+    clone(date: Date): Date;
+    now(): Date;
+    format(date: Date, displayFormat: any): string;
+    parse(value: any, parseFormat: any): Date | null;
+    /**
+     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
+     * invalid date for all other values.
+     */
+    deserialize(value: any): Date | null;
+    /**
+     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
+     * other browsers do not. We remove them to make output consistent and because they interfere with
+     * date parsing.
+     */
+    private stripDirectionalityCharacters;
+    /**
+     * When converting Date object to string, javascript built-in functions may return wrong
+     * results because it applies its internal DST rules. The DST rules around the world change
+     * very frequently, and the current valid rule is not always valid in previous years though.
+     * We work around this problem building a new Date object which has its internal UTC
+     * representation with the local date and time.
+     */
+    private _format;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NativeDateTimeAdapter, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NativeDateTimeAdapter>;
+}
+
+export { CalendarCell, DateTimeAdapter, DateView, DefaultOptions, NativeDateTimeAdapter, OWL_DATETIME_VALIDATORS, OWL_DATETIME_VALUE_ACCESSOR, OWL_DATE_TIME_FORMATS, OWL_DATE_TIME_LOCALE, OWL_DATE_TIME_LOCALE_PROVIDER, OWL_UNIX_TIMESTAMP_DATE_TIME_FORMATS, OptionsTokens, OwlCalendarBodyComponent, OwlCalendarComponent, OwlDateTimeComponent, OwlDateTimeInlineComponent, OwlDateTimeInputDirective, OwlDateTimeIntl, OwlDateTimeModule, OwlDateTimeTriggerDirective, OwlHourInputComponent, OwlMonthViewComponent, OwlMultiYearViewComponent, OwlNativeDateTimeModule, OwlTimerBoxComponent, OwlTimerComponent, OwlYearViewComponent, UnixTimestampDateTimeAdapter, defaultOptionsFactory, multiYearOptionsFactory, optionsProviders, owlDateTimeProviders, owlNativeDateTimeProviders, owlNativeDateTimeProvidersWithFormats, provideOwlDateTime, provideOwlDateTimeOptions, provideOwlDialog, provideOwlNativeDateTime, provideOwlNativeDateTimeWithFormats, provideOwlUnixTimestampDateTime, provideOwlUnixTimestampDateTimeWithFormats };
+export type { DateViewType, Options, OwlDateTimeFormats, PickerMode, PickerType, SelectMode };