import * as i0 from '@angular/core';
import { PipeTransform, OnInit, ChangeDetectorRef, ElementRef, Renderer2, EventEmitter, TemplateRef, AfterViewInit, ViewContainerRef, InjectionToken } from '@angular/core';
import { ALuDateAdapter, LuDateGranularity, ELuDateGranularity, LuTranslation } from '@lucca-front/ng/core';
import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
import { ALuInput } from '@lucca-front/ng/input';
import { ALuPickerPanel, ILuInputWithPicker } from '@lucca-front/ng/picker';
import { Overlay } from '@angular/cdk/overlay';
import { ALuSelectInputComponent } from '@lucca-front/ng/select';
import { Observable } from 'rxjs';

declare class LuDateAdapterPipe<D> implements PipeTransform {
    private _adapter;
    constructor(_adapter: ALuDateAdapter<D>);
    transform(d: D, format?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDateAdapterPipe<any>, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LuDateAdapterPipe<any>, "luDate", true>;
}

declare class LuDateAdapterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDateAdapterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateAdapterModule, never, [typeof LuDateAdapterPipe], [typeof LuDateAdapterPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuDateAdapterModule>;
}

interface LuCalendarInputLabel {
    previous: string;
    next: string;
}

interface ICalendarItem<D> {
    id: string;
    date: D;
    mods: string[];
    label: string;
    isDisabled: boolean;
    granularity: LuDateGranularity;
}

declare abstract class ACalendarItem<D> implements ICalendarItem<D> {
    get id(): string;
    date: D;
    mods: string[];
    isDisabled: boolean;
    label: string;
    readonly granularity: LuDateGranularity;
}
declare class DayItem<D> extends ACalendarItem<D> implements ICalendarItem<D> {
    date: D;
    label: string;
    readonly granularity = ELuDateGranularity.day;
    constructor(date: D, label: string);
}
declare class MonthItem<D> extends ACalendarItem<D> implements ICalendarItem<D> {
    date: D;
    label: string;
    readonly granularity = ELuDateGranularity.month;
    constructor(date: D, label: string);
}
declare class YearItem<D> extends ACalendarItem<D> implements ICalendarItem<D> {
    date: D;
    label: string;
    readonly granularity = ELuDateGranularity.year;
    constructor(date: D, label: string);
}
declare class DecadeItem<D> extends ACalendarItem<D> implements ICalendarItem<D> {
    date: D;
    label: string;
    readonly granularity = ELuDateGranularity.decade;
    constructor(date: D, label: string);
}

declare class LuCalendarItemFactory<D> {
    private _adapter;
    constructor(_adapter: ALuDateAdapter<D>);
    forgeDay(d: D, format?: string): DayItem<D>;
    forgeMonth(d: D, format?: string): MonthItem<D>;
    forgeYear(d: D, format?: string): YearItem<D>;
    forgeDecade(d: D, format?: string): DecadeItem<D>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuCalendarItemFactory<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuCalendarItemFactory<any>>;
}

declare class LuCalendarInputComponent<D> extends ALuInput<D> implements ControlValueAccessor, OnInit, Validator {
    private _locale;
    private _factory;
    private _adapter;
    intl: LuCalendarInputLabel;
    min?: D;
    max?: D;
    granularity: LuDateGranularity;
    startOn: D;
    viewGranularity: LuDateGranularity;
    header: ICalendarItem<D>;
    items: ICalendarItem<D>[];
    get mod(): "mod-yearlyView" | "mod-monthlyView" | "mod-dailyView";
    labels: string[];
    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, _renderer: Renderer2, _locale: string, _factory: LuCalendarItemFactory<D>, _adapter: ALuDateAdapter<D>);
    ngOnInit(): void;
    writeValue(value?: D): void;
    initDayLabels(): void;
    protected render(): void;
    protected renderDailyView(month?: D): void;
    protected renderMonthlyView(year?: D): void;
    protected renderYearlyView(decade?: D): void;
    protected applyDailyMods(): void;
    protected applyMonthlyMods(): void;
    protected applyYearlyMods(): void;
    select(item: ICalendarItem<D>): void;
    protected selectDay(item: ICalendarItem<D>): void;
    protected selectMonth(item: ICalendarItem<D>): void;
    protected selectYear(item: ICalendarItem<D>): void;
    previous(): void;
    next(): void;
    trackBy(_idx: any, item: ICalendarItem<D>): string;
    increaseGranularity(): void;
    protected nextMonth(): void;
    protected nextYear(): void;
    protected nextDecade(): void;
    protected previousMonth(): void;
    protected previousYear(): void;
    protected previousDecade(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuCalendarInputComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuCalendarInputComponent<any>, "lu-calendar", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuCalendarInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuCalendarInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuCalendarInputModule, never, [typeof LuCalendarInputComponent], [typeof LuCalendarInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuCalendarInputModule>;
}

declare class LuDatePickerComponent<D = Date> extends ALuPickerPanel<D> {
    private _adapter;
    _value: D;
    min?: D;
    max?: D;
    granularity: LuDateGranularity;
    startOn: D;
    close: EventEmitter<void>;
    open: EventEmitter<void>;
    hovered: EventEmitter<boolean>;
    onSelectValue: EventEmitter<D>;
    set vcTemplateRef(tr: TemplateRef<unknown>);
    constructor(_adapter: ALuDateAdapter<D>);
    _emitOpenEvent(): void;
    _emitCloseEvent(): void;
    _emitHoveredEvent(h: boolean): void;
    _emitSelectValue(val: D): void;
    setValue(value: D): void;
    _onCalendar(val: D): void;
    _onInput(val: D): void;
    _onEnter(): void;
    _handleKeydown(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDatePickerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuDatePickerComponent<any>, "lu-date-picker", ["LuDatePicker"], { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, { "close": "close"; "open": "open"; "hovered": "hovered"; "onSelectValue": "onSelectValue"; }, never, never, true, never>;
}

declare class LuDateInputDirective<D> extends ALuInput<D, HTMLInputElement> implements Validator, OnInit {
    private _adapter;
    private _focused;
    min?: D;
    max?: D;
    granularity: LuDateGranularity;
    set placeholder(p: string);
    private _intl;
    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLInputElement>, _renderer: Renderer2, _adapter: ALuDateAdapter<D>);
    ngOnInit(): void;
    protected render(): void;
    onInput(event: any): void;
    private parse;
    onFocus(): void;
    onBlur(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDateInputDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuDateInputDirective<any>, "input[luDateInput]", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuDateSelectInputComponent<D> extends ALuSelectInputComponent<D> implements ControlValueAccessor, ILuInputWithPicker<D>, AfterViewInit, Validator {
    protected _changeDetectorRef: ChangeDetectorRef;
    protected _overlay: Overlay;
    protected _elementRef: ElementRef<HTMLElement>;
    protected _viewContainerRef: ViewContainerRef;
    protected _renderer: Renderer2;
    private _adapter;
    min?: D;
    max?: D;
    granularity: LuDateGranularity;
    set inputPlaceholder(p: string);
    hideClearer: boolean;
    protected _startOn: D;
    set startOn(s: D);
    get startOn(): D;
    get format(): string;
    private _intl;
    constructor(_changeDetectorRef: ChangeDetectorRef, _overlay: Overlay, _elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _renderer: Renderer2, _adapter: ALuDateAdapter<D>);
    validate(control: AbstractControl): ValidationErrors | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDateSelectInputComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuDateSelectInputComponent<any>, "lu-date-select", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "granularity": { "alias": "granularity"; "required": false; }; "inputPlaceholder": { "alias": "placeholder"; "required": false; }; "hideClearer": { "alias": "hideClearer"; "required": false; }; "startOn": { "alias": "startOn"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuDateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateModule, never, [typeof LuCalendarInputComponent, typeof LuDatePickerComponent, typeof LuDateInputDirective, typeof LuDateAdapterPipe, typeof LuDateSelectInputComponent], [typeof LuCalendarInputComponent, typeof LuDatePickerComponent, typeof LuDateInputDirective, typeof LuDateAdapterPipe, typeof LuDateSelectInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuDateModule>;
}

declare const luRelativeTimeFormatUnit: readonly ["second", "minute", "hour", "day", "week", "month", "year"];
type LuRelativeTimeFormatUnit = (typeof luRelativeTimeFormatUnit)[number];
interface LuRelativeTime {
    /**
     * The relevant unit for the relative time.
     */
    unit: LuRelativeTimeFormatUnit;
    /**
     * The integer value of the relative time.
     * Negative values are used for past dates.
     */
    value: number;
}

declare class LuHumanizeDateFormatter {
    #private;
    format(relativeTime: LuRelativeTime): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuHumanizeDateFormatter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LuHumanizeDateFormatter>;
}

declare class LuHumanizeDatePipe implements PipeTransform {
    #private;
    transform(value: Date | string | number, allowedUnits?: readonly LuRelativeTimeFormatUnit[]): Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuHumanizeDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<LuHumanizeDatePipe, "luHumanizeDate", true>;
}

declare function getRelativeTime(date: number | Date, reference: number | Date, allowedUnits?: readonly LuRelativeTimeFormatUnit[]): LuRelativeTime;
declare function relativeTimeTimer(date: Date | number, allowedUnits?: readonly LuRelativeTimeFormatUnit[]): Observable<LuRelativeTime>;

declare class LuDateInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDateInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateInputModule, never, [typeof LuDateInputDirective], [typeof LuDateInputDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuDateInputModule>;
}

declare const LU_DATE_INPUT_TRANSLATIONS: InjectionToken<LuTranslation<ILuDateInputLabel>>;
interface ILuDateInputLabel {
    placeholderDay: string;
    placeholderMonth: string;
    placeholderYear: string;
}
declare const luDateInputTranslations: LuTranslation<ILuDateInputLabel>;

declare class LuDatePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDatePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDatePickerModule, never, [typeof LuDatePickerComponent], [typeof LuDatePickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuDatePickerModule>;
}

declare class LuDateSelectInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuDateSelectInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuDateSelectInputModule, never, [typeof LuDateSelectInputComponent], [typeof LuDateSelectInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuDateSelectInputModule>;
}

declare const LU_DATE_SELECT_INPUT_TRANSLATIONS: InjectionToken<LuTranslation<ILuDateSelectInputLabel>>;
interface ILuDateSelectInputLabel {
    placeholderDay: string;
    placeholderMonth: string;
    placeholderYear: string;
}
declare const luDateSelectInputTranslations: LuTranslation<ILuDateSelectInputLabel>;

export { LU_DATE_INPUT_TRANSLATIONS, LU_DATE_SELECT_INPUT_TRANSLATIONS, LuCalendarInputComponent, LuCalendarInputModule, LuDateAdapterModule, LuDateAdapterPipe, LuDateInputDirective, LuDateInputModule, LuDateModule, LuDatePickerComponent, LuDatePickerModule, LuDateSelectInputComponent, LuDateSelectInputModule, LuHumanizeDateFormatter, LuHumanizeDatePipe, getRelativeTime, luDateInputTranslations, luDateSelectInputTranslations, luRelativeTimeFormatUnit, relativeTimeTimer };
export type { ILuDateInputLabel, ILuDateSelectInputLabel, LuRelativeTime, LuRelativeTimeFormatUnit };