import * as i0 from '@angular/core';
import { OnInit, AfterViewInit, OnDestroy, ElementRef, EventEmitter, TemplateRef, ViewRef, ComponentRef } from '@angular/core';
import * as i1 from '@angular/forms';
import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
import { Observable } from 'rxjs';
import * as i16 from '@angular/common/http';
import * as i17 from '@angular/router';
import * as i19 from '@angular/common';

interface DataSourceItem<K, L> {
    key: K;
    label: L;
}
type DataSource<K, L> = DataSourceItem<K, L>[];
interface DecoratedDataSourceItem {
    key: any;
    label: string;
    labelPrefix: string;
    labelMatch: string;
    labelPostfix: string;
}
type DecoratedDataSource = DecoratedDataSourceItem[];

declare class AutocompleteComponent implements ControlValueAccessor, Validator, OnInit, AfterViewInit, OnDestroy {
    private cd;
    private document;
    private appendToContainer;
    static idCounter: number;
    i0: ElementRef;
    completeDiv: ElementRef;
    private _dataSource;
    private _placeholder;
    private _value;
    private lostFocusHandled;
    private t0;
    showSpinner: boolean;
    touched: boolean;
    completionList: DecoratedDataSource;
    showCompletion: boolean;
    focusItem: DataSourceItem<any, string>;
    valueChange: EventEmitter<any>;
    dataSourceChange: EventEmitter<DataSource<any, string>>;
    inputId: string;
    disabled: boolean | null;
    readonly: boolean | null;
    label: string;
    /** If canAddNewValues, user can type items not present in the data-source. */
    canAddNewValues: boolean;
    /** After cleaning the selection should the completion list remain open or closed:
     *  false: (default) close on filters, to clean a filter and select all.
     *  true: keep open (when the action most likely is to pick another one).
     */
    keepOpenAfterDelete: boolean;
    /** Append dropdown to body or custom selector. Uses position absolute. */
    appendTo?: string;
    get value(): any;
    set value(v: any);
    get dataSource(): DataSource<any, string>;
    set dataSource(v: DataSource<any, string>);
    required: boolean;
    set placeholder(v: string);
    get placeholder(): string;
    resolveLabelsFunction?: (instance: any, keys: any[]) => Observable<DataSource<any, string>>;
    populateFunction?: (instance: any, search: string) => Observable<DataSource<any, string>>;
    instance: any;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    registerOnValidatorChange(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    clear(): void;
    private completeLabel;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private handleAppendTo;
    private removeDropdownFromContainer;
    private updateDropdownPosition;
    onInputResized(): void;
    private setSameWidth;
    onKeydown(event: KeyboardEvent, label: string): void;
    onKeypress(event: KeyboardEvent, label: string): void;
    onKeyup(event: KeyboardEvent, label: string): void;
    private focusOnNext;
    private focusOnPrevious;
    onLostFocus(label: string): void;
    complete(item: DataSourceItem<Record<string, unknown>, string>): void;
    toggleCompletion(show: boolean, label: string): void;
    get selectedOption(): string;
    private ensureItemVisible;
    private syncCustomValue;
    /** Pick selection based on text filtering (ingnores drowdown state) */
    private pickSelectionOrFirstMatch;
    showCompletionList(text: string): void;
    private spinnerVisibility;
    private hasExternalDataSource;
    private computeCompletionList;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AutocompleteComponent, "lux-autocomplete", never, { "inputId": { "alias": "inputId"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "label": { "alias": "label"; "required": false; }; "canAddNewValues": { "alias": "canAddNewValues"; "required": false; }; "keepOpenAfterDelete": { "alias": "keepOpenAfterDelete"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "value": { "alias": "value"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "required": { "alias": "required"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "resolveLabelsFunction": { "alias": "resolveLabelsFunction"; "required": false; }; "populateFunction": { "alias": "populateFunction"; "required": false; }; "instance": { "alias": "instance"; "required": false; }; }, { "valueChange": "valueChange"; "dataSourceChange": "dataSourceChange"; }, never, never, true, never>;
}

declare class AutocompleteListComponent implements ControlValueAccessor, Validator, OnInit {
    static idCounter: number;
    auto: AutocompleteListComponent;
    literals: {
        en: {
            placeholder: string;
            deleteLabelTemplate: string;
            addMessage: string;
        };
        es: {
            placeholder: string;
            deleteLabelTemplate: string;
            addMessage: string;
        };
    };
    internalDataSource: DataSource<any, string>;
    private autoPopulate;
    private _value;
    set value(val: any[]);
    get value(): any[];
    labels: string[];
    newEntry: any;
    canAdd: boolean;
    touched: boolean;
    private _lang;
    get lang(): string;
    set lang(l: string);
    inputId: string;
    dataSource: DataSource<any, any>;
    placeholder?: string;
    disabled: boolean;
    deleteLabelTemplate?: string;
    addMessage?: string;
    required: boolean;
    resolveLabelsFunction?: (instance: any, ids: any[]) => Observable<DataSource<any, string>>;
    populateFunction?: (instance: any, search: string) => Observable<DataSource<any, string>>;
    instance: any;
    valueChange: EventEmitter<any[]>;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    registerOnValidatorChange(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    ngOnInit(): void;
    ensureLabelsForIds(): void;
    removeAt(index: number): void;
    onValueChange(): void;
    onNewEntryChange(event: KeyboardEvent, auto: AutocompleteComponent): void;
    populateWith(searchText: string): void;
    updateCanAdd(): void;
    addNew(auto: AutocompleteComponent): void;
    getDeleteMessage(label: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutocompleteListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AutocompleteListComponent, "lux-autocomplete-list", never, { "value": { "alias": "value"; "required": false; }; "lang": { "alias": "lang"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "deleteLabelTemplate": { "alias": "deleteLabelTemplate"; "required": false; }; "addMessage": { "alias": "addMessage"; "required": false; }; "required": { "alias": "required"; "required": false; }; "resolveLabelsFunction": { "alias": "resolveLabelsFunction"; "required": false; }; "populateFunction": { "alias": "populateFunction"; "required": false; }; "instance": { "alias": "instance"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

interface BreadcrumbItem {
    label: string;
    url: string;
}
declare class LuxBreadcrumbComponent implements OnInit, OnDestroy {
    private route;
    private activedRoute;
    breadcrumbs: BreadcrumbItem[];
    private subs;
    imagePath: string;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private addBreadcrumbs;
    private getUrl;
    private getLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxBreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxBreadcrumbComponent, "lux-breadcrumb", never, {}, {}, never, never, true, never>;
}

declare class CheckboxComponent implements ControlValueAccessor, OnInit, AfterViewInit {
    static idCounter: number;
    ck: ElementRef;
    private _lang;
    set lang(l: string);
    get lang(): string;
    private internalValue;
    get value(): boolean;
    set value(v: boolean);
    get tabindexValue(): string;
    label: string;
    name: string;
    private _disabled;
    get disabled(): boolean;
    set disabled(v: boolean);
    inputId: string;
    literals: {
        en: {
            yesLabel: string;
            noLabel: string;
        };
        es: {
            yesLabel: string;
            noLabel: string;
        };
    };
    touched: boolean;
    valueChange: EventEmitter<boolean>;
    private cdr;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    clicked(): void;
    onKey(event: KeyboardEvent): void;
    private syncModel;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxComponent, "lux-checkbox", never, { "lang": { "alias": "lang"; "required": false; }; "value": { "alias": "value"; "required": false; }; "label": { "alias": "label"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class DatetimeComponent implements OnInit, ControlValueAccessor, Validator {
    static idCounter: number;
    dateInput: ElementRef;
    timeInput: ElementRef;
    touched: boolean;
    dirty: boolean;
    lastErrors: ValidationErrors | null;
    private _disabled;
    private _required;
    private _value;
    dateValue?: string;
    timeValue?: string;
    userErrors: {
        en: {
            required: string;
            min: string;
            max: string;
        };
        es: {
            required: string;
            min: string;
            max: string;
        };
    };
    min?: string;
    max?: string;
    includeSeconds: boolean;
    localTime: boolean;
    get className(): string;
    lang: string;
    inlineErrors: boolean;
    inputId: string;
    ariaLabel: string;
    readonly: boolean | null;
    set disabled(v: string | boolean);
    get disabled(): string | boolean;
    set required(v: boolean);
    get required(): boolean;
    set value(v: string);
    get value(): string;
    valueChange: EventEmitter<any>;
    keyPress: EventEmitter<KeyboardEvent>;
    onChange: (_value: any) => void;
    onTouched: () => void;
    constructor();
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    private setDateInControl;
    private setTimeInControl;
    private setValueInControl;
    clear(): void;
    isClearable(): boolean;
    registerOnValidatorChange(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    ngOnInit(): void;
    onLostFocus(): void;
    onKeyPress(event: KeyboardEvent): void;
    onEventDatetime(newDate: string, newTime: string): void;
    checkClassName(): string;
    setPatterns(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimeComponent, "lux-datetime", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "includeSeconds": { "alias": "includeSeconds"; "required": false; }; "localTime": { "alias": "localTime"; "required": false; }; "lang": { "alias": "lang"; "required": false; }; "inlineErrors": { "alias": "inlineErrors"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "keyPress": "keyPress"; }, never, never, true, never>;
}

/** Filter component to query for objects. */
declare class FilterComponent implements ControlValueAccessor, OnInit, OnDestroy {
    static idCounter: number;
    private touched;
    private _searchValue;
    disabled: boolean;
    /** id for the input. If left blank, it is autogenerated */
    inputId: string;
    /** Placeholder default text. */
    placeholder: string;
    /** Search value introduced by the user. */
    get searchValue(): string;
    set searchValue(v: string);
    /** Search on type: (default true) Auto-search when user types in. */
    searchOnType: boolean;
    /** Custom aria label in case of not using a label */
    ariaLabel: string;
    private debounceValue;
    /** Debounce time in milliseconds. (defaults to 300 ms) */
    set debounce(val: number);
    get debounce(): number;
    /** Search value changed by user. */
    searchValueChange: EventEmitter<string>;
    searchValue$: Observable<string>;
    private subject;
    private sub;
    constructor();
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    search(): void;
    keyup(event: KeyboardEvent, newValue: string): void;
    onInputValueChange(newValue: string): void;
    private recreateObservable;
    private freeSubscriptions;
    private searchNow;
    private addEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent, "lux-filter", never, { "disabled": { "alias": "disabled"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchValue": { "alias": "searchValue"; "required": false; }; "searchOnType": { "alias": "searchOnType"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; }, { "searchValueChange": "searchValueChange"; }, never, never, true, never>;
}

/** From https://en.wikipedia.org/wiki/GeoJSON
 *  Stored as [ longitude, latitude ]
 */
interface GeoPoint {
    type: 'Point';
    coordinates: number[];
}

interface SearchResult {
    place_id: number;
    lat: number;
    lon: number;
    display_name: string;
    icon: string;
}
declare class GeolocationService {
    private http;
    private debouncePeriodMs;
    private cacheSize;
    private lastQueriesWithResults;
    private lastQueriesLru;
    private currentSearch$;
    private currentQuery$;
    constructor();
    searchGeolocation(query: string): Observable<SearchResult[]>;
    getLabels(instance: GeolocationService, keys: GeoPoint[]): Observable<DataSource<GeoPoint, string>>;
    getData(instance: GeolocationService, search: string): Observable<DataSource<GeoPoint, string>>;
    private getFromCache;
    private addToCache;
    private revomeFromCache;
    private getLatestQuery;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeolocationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GeolocationService>;
}

declare class GeolocationComponent implements OnInit {
    private modalService;
    locationService: GeolocationService;
    static idCounter: number;
    latitude: ElementRef;
    longitude: ElementRef;
    map?: ElementRef;
    touched: boolean;
    dirty: boolean;
    lastErrors: ValidationErrors | null;
    private _disabled;
    private _required;
    private _value;
    latitudeValue?: number;
    longitudeValue?: number;
    isValidNumber: (value: string | number | undefined | null) => boolean;
    i18n: {
        en: {
            lat: string;
            lon: string;
            selectLocation: string;
            location: string;
            selectAction: string;
            cancelAction: string;
            closeAction: string;
            typeToSearch: string;
            cardinalPoints: {
                north: string;
                south: string;
                east: string;
                west: string;
            };
            userErrors: {
                required: string;
                minLatitude: string;
                maxLatitude: string;
                minLongitude: string;
                maxLongitude: string;
            };
        };
        es: {
            lat: string;
            lon: string;
            selectLocation: string;
            location: string;
            selectAction: string;
            cancelAction: string;
            closeAction: string;
            typeToSearch: string;
            cardinalPoints: {
                north: string;
                south: string;
                east: string;
                west: string;
            };
            userErrors: {
                required: string;
                minLatitude: string;
                maxLatitude: string;
                minLongitude: string;
                maxLongitude: string;
            };
        };
    };
    minLatitude: number;
    maxLatitude: number;
    minLongitude: number;
    maxLongitude: number;
    step: number;
    zoom: number;
    get className(): string;
    lang: string;
    inlineErrors: boolean;
    inputId: string;
    ariaLabel: string;
    readonly: boolean | null;
    set disabled(v: string | boolean);
    get disabled(): string | boolean;
    set required(v: boolean);
    get required(): boolean;
    set value(v: GeoPoint);
    get value(): GeoPoint;
    valueChange: EventEmitter<GeoPoint>;
    keyPress: EventEmitter<KeyboardEvent>;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    private setLatitudeInControl;
    private setLongitudeInControl;
    clear(): void;
    isClearable(): boolean;
    registerOnValidatorChange(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    ngOnInit(): void;
    roundToStepAndUpdateLatitudeAndLongitude(newLatitudeAndLongitude: number[]): void;
    onLostFocus(): void;
    onEventLatitude(newLatitude: string): void;
    onEventLongitude(newLongitude: string): void;
    onKeyPress(event: KeyboardEvent): void;
    checkClassName(): string;
    openModalMap(modal: TemplateRef<any>): void;
    onSearchLocationChanged(newValue: GeoPoint, map: any): void;
    get mapTitle(): string;
    get self(): GeolocationComponent;
    getLabels(instance: GeolocationComponent, keys: GeoPoint[]): Observable<DataSource<GeoPoint, string>>;
    getData(instance: GeolocationComponent, search: string): Observable<DataSource<GeoPoint, string>>;
    setPatterns(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeolocationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GeolocationComponent, "lux-geolocation", never, { "minLatitude": { "alias": "minLatitude"; "required": false; }; "maxLatitude": { "alias": "maxLatitude"; "required": false; }; "minLongitude": { "alias": "minLongitude"; "required": false; }; "maxLongitude": { "alias": "maxLongitude"; "required": false; }; "step": { "alias": "step"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "lang": { "alias": "lang"; "required": false; }; "inlineErrors": { "alias": "inlineErrors"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "keyPress": "keyPress"; }, never, never, true, never>;
}

/**
 * A service that holds the functionality for advanced handling of regular expressions
 */
declare class RegexpService {
    constructor();
    private removeOuterRoundBrackets;
    private isQuantifier;
    private parseMinimalAmountOfQuantifier;
    private sliceRegexByOr;
    private sliceRegexByThen;
    suggestion(beginning: string, regularExpressionString: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RegexpService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RegexpService>;
}

declare class InputComponent implements OnInit, ControlValueAccessor, Validator {
    regexpService: RegexpService;
    private cdr;
    static idCounter: number;
    input: ElementRef;
    textarea: ElementRef;
    colorpicker: ElementRef;
    touched: boolean;
    dirty: boolean;
    lastErrors: ValidationErrors | null;
    private _disabled;
    private _value;
    private _type;
    private _placeholder;
    private _pattern?;
    private _regexp?;
    private _currency;
    private _required;
    userErrors: {
        en: {
            required: string;
            min: string;
            max: string;
            email: string;
            url: string;
            color: string;
        };
        es: {
            required: string;
            min: string;
            max: string;
            email: string;
            url: string;
            color: string;
        };
    };
    domain: string;
    rows?: number | string;
    cols?: number | string;
    step?: number;
    min?: number | string;
    max?: number | string;
    get className(): string;
    get color(): string;
    lang: string;
    inlineErrors: boolean;
    inputId: string;
    ariaLabel: string;
    readonly: boolean | null;
    set disabled(v: string | boolean);
    get disabled(): string | boolean;
    set pattern(p: string | undefined);
    get pattern(): string | undefined;
    set currency(v: string);
    get currency(): string;
    set placeholder(v: string);
    get placeholder(): string;
    set required(v: boolean);
    get required(): boolean;
    set type(v: string);
    get type(): string;
    set value(v: any);
    get value(): any;
    valueChange: EventEmitter<any>;
    keyPress: EventEmitter<KeyboardEvent>;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    private setValueInControl;
    registerOnValidatorChange(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    ngOnInit(): void;
    onLostFocus(): void;
    onKeyUp(newValue: string): void;
    onChangeValue(newValue: string): void;
    onKeyPress(event: KeyboardEvent): void;
    onColorPicked(newValue: string): void;
    isUrl(): boolean;
    isColor(): boolean;
    isNumber(): boolean;
    isPercentage(): boolean;
    isPermillage(): boolean;
    hasPrefix(): boolean;
    hasPostfix(): boolean;
    checkClassName(): string;
    checkColor(): string;
    checkType(type: string): void;
    setEmailPatterns(): void;
    setUrlPatterns(): void;
    setColorPatterns(): void;
    setDatePatterns(): void;
    setTimePatterns(): void;
    setPasswordPatterns(): void;
    setNumberPatterns(): void;
    setCurrencyPatterns(): void;
    setPercentagePatterns(): void;
    setPermillagePatterns(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "lux-input", never, { "rows": { "alias": "rows"; "required": false; }; "cols": { "alias": "cols"; "required": false; }; "step": { "alias": "step"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "lang": { "alias": "lang"; "required": false; }; "inlineErrors": { "alias": "inlineErrors"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "currency": { "alias": "currency"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "required": { "alias": "required"; "required": false; }; "type": { "alias": "type"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "keyPress": "keyPress"; }, never, never, true, never>;
}

type PlacementValue = 'left' | 'right' | 'top' | 'bottom';

declare class TooltipContentRef {
    viewRef?: ViewRef;
    componentRef?: ComponentRef<any>;
    constructor(viewRef?: ViewRef, componentRef?: ComponentRef<any>);
}

/**
 * Tooltip directive
 */
declare class LuxTooltipDirective {
    private elHost;
    private tooltipService;
    /** Tooltip title */
    luxTooltip: any;
    /** Component, TemplateRef or String */
    content: any;
    /** Placement */
    placement: PlacementValue;
    tooltipRef: TooltipContentRef;
    onMouseEnter(): void;
    onMouseLeave(): void;
    onClick(): void;
    show(component: any, elHost: ElementRef, placement: PlacementValue): TooltipContentRef;
    remove(tooltipRef: TooltipContentRef): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LuxTooltipDirective, "[luxTooltip]", never, { "luxTooltip": { "alias": "luxTooltip"; "required": false; }; "content": { "alias": "content"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxModalWindowComponent implements OnInit, AfterViewInit, OnDestroy {
    private _document;
    private _elRef;
    private _elWithFocus;
    ariaDescribedBy: string;
    ariaLabelledBy: string;
    backdrop: boolean | string;
    keyboard: boolean;
    windowClass: string;
    dismissEvent: EventEmitter<any>;
    get class(): string;
    role: string;
    tabindex: string;
    ariamodal: boolean;
    get hostAriaLabelledBy(): string;
    get hostAriaDescribedBy(): string;
    backdropClick(event: any): void;
    escKey(event: any): void;
    dismiss(reason: any): void;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxModalWindowComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxModalWindowComponent, "lux-modal-window", never, { "ariaDescribedBy": { "alias": "ariaDescribedBy"; "required": false; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; }; "backdrop": { "alias": "backdrop"; "required": false; }; "keyboard": { "alias": "keyboard"; "required": false; }; "windowClass": { "alias": "windowClass"; "required": false; }; }, { "dismissEvent": "dismissEvent"; }, never, ["*"], true, never>;
}

declare class LuxModalBackdropComponent {
    backdropClass: string;
    class: string;
    style: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxModalBackdropComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LuxModalBackdropComponent, "lux-modal-backdrop", never, { "backdropClass": { "alias": "backdropClass"; "required": false; }; }, {}, never, never, true, never>;
}

declare class MapComponent implements OnInit, AfterViewInit {
    static idCounter: number;
    private loaded$;
    private _map;
    mapId: any;
    _zoom: number;
    set zoom(zoom: number);
    get zoom(): number;
    _center: GeoPoint;
    set center(center: GeoPoint);
    get center(): GeoPoint;
    _readonly: boolean;
    set readonly(readonly: boolean);
    get readonly(): boolean;
    private _marker;
    private _markerInteraction;
    private _markerCoordinates;
    private set markerCoordinates(value);
    private get markerCoordinates();
    set markerPoint(markerPoint: GeoPoint);
    get markerPoint(): GeoPoint;
    valueChange: EventEmitter<GeoPoint>;
    private _markerSource;
    private _markerStyle;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    private initMap;
    private addMarkerAtCoordinates;
    private removeMarker;
    private getMarkerCoordinates;
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MapComponent, "lux-map", never, { "mapId": { "alias": "mapId"; "required": false; }; "zoom": { "alias": "zoom"; "required": false; }; "center": { "alias": "center"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "markerCoordinates": { "alias": "markerCoordinates"; "required": false; }; "markerPoint": { "alias": "markerPoint"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

interface PaginationInfo {
    /** How many total items there are in all pages */
    total: number;
    /** The current page (0-index) */
    page: number;
    /** How many items we want to show per page */
    pageSize: number;
    /** How many pages between next/prev */
    pagesToShow: number;
}

declare class PaginationComponent implements OnInit {
    literals: {
        en: {
            first: string;
            previous: string;
            next: string;
            last: string;
        };
        es: {
            first: string;
            previous: string;
            next: string;
            last: string;
        };
    };
    first: string;
    previous: string;
    next: string;
    last: string;
    showPagination: boolean;
    hidePrevious: boolean;
    lastPage: boolean;
    totalPages: number;
    displayNextEllipsis: boolean;
    displayPreviousEllipsis: boolean;
    pages: number[];
    goToPage: EventEmitter<number>;
    pageSizeChange: EventEmitter<number>;
    /** Current page, total items and items to show per page */
    private paginationInfoValue;
    private _lang;
    set lang(l: string);
    get lang(): string;
    set paginationInfo(value: PaginationInfo);
    get paginationInfo(): PaginationInfo;
    constructor();
    ngOnInit(): void;
    pageSizeChanged(pageSize: number): void;
    onPage(n: number): void;
    onFirst(): void;
    onLast(): void;
    onNext(): void;
    onPrevious(): void;
    private syncState;
    private calculatePages;
    private loadLanguage;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "lux-pagination", never, { "lang": { "alias": "lang"; "required": false; }; "paginationInfo": { "alias": "paginationInfo"; "required": false; }; }, { "goToPage": "goToPage"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
}

interface RadioItem {
    name?: string;
    label: string;
    value: any;
}
declare class RadiogroupComponent implements ControlValueAccessor, Validator {
    private touched;
    name: string;
    disabled: boolean | null;
    readonly: boolean | null;
    required: boolean | null;
    set items(col: RadioItem[]);
    get items(): RadioItem[];
    itemsChange: EventEmitter<RadioItem[]>;
    set value(v: any);
    get value(): any;
    valueChange: EventEmitter<any>;
    private _value;
    private _items;
    constructor();
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    registerOnValidatorChange(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    setValue(event: MouseEvent, item: RadioItem): void;
    ensureHasUniqueName(item: RadioItem, index: number): RadioItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<RadiogroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RadiogroupComponent, "lux-radiogroup", never, { "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "items": { "alias": "items"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "itemsChange": "itemsChange"; "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class SelectComponent implements ControlValueAccessor, Validator {
    id: string;
    disabled: boolean;
    required: boolean;
    /** Allow multiple elements */
    multiple: boolean;
    value: string[];
    valueChange: EventEmitter<string[]>;
    placeholder: string;
    /** If set, check there is no duplicates in the data. */
    unique: boolean;
    /** Validation function for new items. Returns error or null if valid */
    validateItem: (item: string) => string;
    newEntry: string;
    error: any;
    isValidNewEntry: boolean;
    private touched;
    constructor();
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(onChange: any): void;
    registerOnTouched(onTouched: any): void;
    markAsTouched(): void;
    setDisabledState(disabled: boolean): void;
    registerOnValidatorChange(): void;
    validate(control: AbstractControl): ValidationErrors | null;
    get canAdd(): boolean;
    add(val: string): void;
    remove(index: number): void;
    onKeyPress(event: KeyboardEvent): void;
    onChangeNewEntry(newValue: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "lux-select", never, { "id": { "alias": "id"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "unique": { "alias": "unique"; "required": false; }; "validateItem": { "alias": "validateItem"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

interface LuxTooltipContext {
    message: string;
}

/**
 * Default Tooltip Component
 */
declare class TooltipComponent {
    context: LuxTooltipContext;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "lux-tooltip", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
}

declare class VoiceRecognitionDirective implements OnInit {
    private el;
    private renderer;
    language: string;
    private recognition;
    private isRecognizing;
    private mic;
    constructor();
    ngOnInit(): void;
    microphoneClick(): void;
    onRecognized(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VoiceRecognitionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VoiceRecognitionDirective, "[luxVoiceRecognition]", never, { "language": { "alias": "language"; "required": false; }; }, {}, never, never, true, never>;
}

declare class LuxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LuxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LuxModule, never, [typeof i1.FormsModule, typeof FilterComponent, typeof GeolocationComponent, typeof InputComponent, typeof AutocompleteListComponent, typeof AutocompleteComponent, typeof CheckboxComponent, typeof DatetimeComponent, typeof LuxBreadcrumbComponent, typeof LuxTooltipDirective, typeof LuxModalWindowComponent, typeof LuxModalBackdropComponent, typeof MapComponent, typeof PaginationComponent, typeof RadiogroupComponent, typeof i16.HttpClientModule, typeof i1.ReactiveFormsModule, typeof i17.RouterModule, typeof SelectComponent, typeof i19.CommonModule, typeof TooltipComponent, typeof VoiceRecognitionDirective], [typeof AutocompleteComponent, typeof AutocompleteListComponent, typeof FilterComponent, typeof CheckboxComponent, typeof DatetimeComponent, typeof InputComponent, typeof GeolocationComponent, typeof LuxTooltipDirective, typeof MapComponent, typeof SelectComponent, typeof PaginationComponent, typeof RadiogroupComponent, typeof VoiceRecognitionDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LuxModule>;
}

declare class ContentRef {
    nodes: any[];
    viewRef?: ViewRef;
    componentRef?: ComponentRef<any>;
    constructor(nodes: any[], viewRef?: ViewRef, componentRef?: ComponentRef<any>);
}

declare class ModalRef {
    private _windowCmptRef;
    private _contentRef;
    private _backdropCmptRef?;
    private _beforeDismiss?;
    private _resolve;
    private _reject;
    /**
     * The instance of a component used for the modal content.
     *
     * When a `TemplateRef` is used as the content, will return `undefined`.
     */
    get componentInstance(): any;
    /**
     * The promise that is resolved when the modal is closed and rejected when the modal is dismissed.
     */
    result: Promise<any>;
    constructor(_windowCmptRef: ComponentRef<LuxModalWindowComponent>, _contentRef: ContentRef, _backdropCmptRef?: ComponentRef<LuxModalBackdropComponent>, _beforeDismiss?: () => any);
    /**
     * Closes the modal with an optional `result` value.
     *
     * The `NgbMobalRef.result` promise will be resolved with the provided value.
     */
    close(result?: any): void;
    private _dismiss;
    /**
     * Dismisses the modal with an optional `reason` value.
     *
     * The `NgbModalRef.result` promise will be rejected with the provided value.
     */
    dismiss(reason?: any): void;
    private _removeModalElements;
}

interface LuxModalOptions {
    ariaDescribedBy?: string;
    ariaLabelledBy?: string;
    backdrop?: boolean;
    keyboard?: boolean;
    windowClass?: string;
    backdropClass?: string;
}

/**
 * A service that it allow open an close modal components
 */
declare class ModalService {
    private modalStack;
    private moduleCFR;
    /**Open a modal component
     * @param content TemplateRef
     */
    open(content: TemplateRef<any>, options?: LuxModalOptions): ModalRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<ModalService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ModalService>;
}

export { AutocompleteComponent, AutocompleteListComponent, CheckboxComponent, DatetimeComponent, FilterComponent, GeolocationComponent, InputComponent, LuxBreadcrumbComponent, LuxModule, LuxTooltipDirective, MapComponent, ModalRef, ModalService, PaginationComponent, RadiogroupComponent, SelectComponent, VoiceRecognitionDirective };
export type { BreadcrumbItem, DataSource, DataSourceItem, DecoratedDataSource, DecoratedDataSourceItem, RadioItem };