import { Observable } from 'rxjs';
import * as i0 from '@angular/core';
import { EventEmitter, ViewRef, TemplateRef, ChangeDetectorRef, ElementRef, Renderer2, OnInit } from '@angular/core';
import { ControlValueAccessor, NgControl } from '@angular/forms';

interface ILuClearer<T> {
    onClear: Observable<T>;
}
declare abstract class ALuClearer<T> implements ILuClearer<T> {
    onClear: Observable<T>;
}

interface LuClearerLabel {
    clear: string;
}

declare class LuInputClearerComponent<T> extends ALuClearer<T> implements ILuClearer<T> {
    intl: LuClearerLabel;
    onClear: EventEmitter<T>;
    onClick($event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputClearerComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuInputClearerComponent<any>, "lu-input-clearer", ["luClearer"], {}, { "onClear": "onClear"; }, never, never, true, never>;
}

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

interface ILuInputDisplayer<T> {
    multiple: boolean;
    getViewRef(value: T | T[]): ViewRef;
}
declare abstract class ALuInputDisplayer<T> implements ILuInputDisplayer<T> {
    multiple: boolean;
    abstract getViewRef(value: T | T[]): ViewRef;
}

/**
 * @deprecated
 */
declare class LuInputDisplayerDirective<T> extends ALuInputDisplayer<T> implements ILuInputDisplayer<T> {
    protected template: TemplateRef<LuInputDisplayerContext<T>>;
    set argMultiple(m: boolean);
    set inputMultiple(m: boolean | string);
    constructor(template: TemplateRef<LuInputDisplayerContext<T>>);
    getViewRef(value: T | T[]): ViewRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputDisplayerDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuInputDisplayerDirective<any>, "[luDisplayer]", never, { "argMultiple": { "alias": "luDisplayerMultiple"; "required": false; }; "inputMultiple": { "alias": "multiple"; "required": false; }; }, {}, never, never, true, never>;
}
declare class LuInputDisplayerContext<T> {
    $implicit: T | T[];
    constructor($implicit: T | T[]);
}

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

type ILuInput = ControlValueAccessor;
declare abstract class ALuInput<T, U extends HTMLElement = HTMLElement> implements ILuInput {
    protected _changeDetectorRef: ChangeDetectorRef;
    protected _elementRef: ElementRef<U>;
    protected _renderer: Renderer2;
    protected _placeholder: string;
    get placeholder(): string;
    protected _value: T;
    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<U>, _renderer: Renderer2);
    setValue(value: T): void;
    get value(): T;
    set value(value: T);
    writeValue(value: T): void;
    protected _cvaOnChange: (value: T) => void;
    registerOnChange(fn: (value: T) => void): void;
    protected _onTouched: () => void;
    registerOnTouched(fn: () => void): void;
    protected isEmpty(): boolean;
    protected applyClasses(): void;
    protected abstract render(): void;
}

/**
 * adds class is-filled when model is empty
 */
declare class LuInputDirective implements OnInit {
    protected _elementRef: ElementRef;
    protected _renderer: Renderer2;
    protected _ngControl: NgControl;
    constructor(_elementRef: ElementRef, _renderer: Renderer2, _ngControl: NgControl);
    protected isEmpty(value: any): boolean;
    protected applyClasses(value: any): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuInputDirective, "[luInput]", never, {}, {}, never, never, true, never>;
}

declare class LuInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuInputModule, never, [typeof LuInputDirective, typeof LuInputDisplayerDirective, typeof LuInputClearerComponent], [typeof LuInputDirective, typeof LuInputDisplayerDirective, typeof LuInputClearerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuInputModule>;
}

export { ALuClearer, ALuInput, ALuInputDisplayer, LuInputClearerComponent, LuInputClearerModule, LuInputDirective, LuInputDisplayerContext, LuInputDisplayerDirective, LuInputDisplayerModule, LuInputModule };
export type { ILuClearer, ILuInput, ILuInputDisplayer };