import * as i0 from '@angular/core';
import { ComponentRef, ApplicationRef, Type, Injector, ViewContainerRef, OnDestroy, AfterViewInit, OnInit, EventEmitter, ViewRef, ProviderToken, OnChanges, ElementRef, SimpleChanges, DoCheck, NgIterable, TrackByFunction, TemplateRef, IterableDiffers, ExistingProvider, ChangeDetectorRef } from '@angular/core';
import * as i1 from '@angular/common';
import { Observable } from 'rxjs';
import { AnimationEvent } from '@angular/animations';
import { ControlValueAccessor } from '@angular/forms';
import Popper from 'popper.js';

declare class UIDialogRef<T> {
    private _container;
    private _appRef;
    config: UIDialogConfig;
    componentInstance: T;
    private _subscription;
    private _afterClosed;
    private _disposeCallback;
    constructor(_container: ComponentRef<UIDialogContainer>, _appRef: ApplicationRef, config: UIDialogConfig);
    attachComponent<T>(componentType: Type<T>, injector?: Injector): ComponentRef<T>;
    close(dialogResult?: any): void;
    afterClosed(): Observable<any>;
}

declare class UIDialog {
    private _appRef;
    private _injector;
    constructor(_appRef: ApplicationRef, _injector: Injector);
    open<T>(component: Type<T>, config: UIDialogConfig, viewContainer?: ViewContainerRef): UIDialogRef<T>;
    createDialogContent<T>(component: Type<T>, containerRef: ComponentRef<UIDialogContainer>, config: UIDialogConfig): UIDialogRef<T>;
    /** Gets the root HTMLElement for an instantiated component. */
    private getComponentRootNode;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIDialog, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UIDialog>;
}
declare class UIDialogConfig {
    stickyDialog: boolean;
    backdrop: boolean;
}

declare const DARK_THEME = "dark_theme";
declare const LIGHT_THEME = "light_theme";
type ThemeName = 'dark_theme' | 'light_theme';
declare class DarkThemeService implements OnDestroy {
    private platformId;
    private _globalListenerInstance;
    private _themeChangeSubject;
    get themeChange(): Observable<string>;
    constructor(platformId: object);
    changeTheme(theme: ThemeName): void;
    getCurrentTheme(): ThemeName;
    ngOnDestroy(): void;
    private initGlobalListener;
    private checkTheme;
    static ɵfac: i0.ɵɵFactoryDeclaration<DarkThemeService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DarkThemeService>;
}

declare class UIDialogContainer implements AfterViewInit, OnInit, OnDestroy {
    private _viewContainerRef;
    private _darkThemeService;
    private _subscription;
    get backdropOpacity(): number;
    get backdropState(): string;
    insideParent: boolean;
    isDarkTheme: boolean;
    backDropContainerRef: ViewContainerRef;
    dialogConfig: UIDialogConfig;
    close: EventEmitter<any>;
    contentViewRef: ViewRef;
    constructor(_viewContainerRef: ViewContainerRef, _darkThemeService: DarkThemeService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    onClickBackDrop($event: Event): void;
    attachDialogContent<T>(componentType: Type<T>, injector: Injector): ComponentRef<T>;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIDialogContainer, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UIDialogContainer, "ui-dialog-container", never, { "dialogConfig": { "alias": "dialogConfig"; "required": false; }; }, { "close": "close"; }, never, never, true, never>;
}

declare class UIDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UIDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UIDialogModule, never, [typeof i1.CommonModule, typeof UIDialogContainer], [typeof UIDialogContainer]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UIDialogModule>;
}

declare class UIToast {
    private _injector;
    private _appRef;
    private platformId;
    private _currentActiveToast;
    private _pendingToast;
    private _pendingToastDuration;
    private _leaveAnimationSubscription;
    private timerId;
    constructor(_injector: Injector, _appRef: ApplicationRef, platformId: object);
    make<T>(componentType?: Type<T>): UIToastRef<T>;
    makeText(): UIToastRef<UIToastComponent>;
    makeComponent<T>(toastRef: UIToastRef<T>): ComponentRef<T>;
    activeToast<T>(component: ComponentRef<T>, duration: number): void;
    activePendingToast(): void;
    deactiveToast(): void;
    /** Gets the root HTMLElement for an instantiated component. */
    private _getComponentRootNode;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIToast, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UIToast>;
}
declare const LONG_TOAST: number;
declare const SHORT_TOAST: number;

declare class UIToastRef<T> {
    private _toastService;
    componentType: Type<T>;
    duration: number;
    messageObject: any;
    constructor(_toastService: UIToast, componentType: Type<T>);
    show(message: any): void;
    hide(): void;
    private _bindingMessage;
}

/**
 * Animation handler for toast component which has enter and leave animations.
 */
interface UIToastAnimation {
    animationEvent: EventEmitter<any>;
    uiLeaveAnimationDone(event: AnimationEvent): void;
}

declare class UIToastComponent implements OnInit, OnDestroy, UIToastAnimation {
    private _toastRef;
    private _darkThemeService;
    private _subscription;
    message: string;
    animationEvent: EventEmitter<any>;
    isDarkTheme: boolean;
    constructor(_toastRef: UIToastRef<UIToastComponent>, _darkThemeService: DarkThemeService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    uiLeaveAnimationDone(event: AnimationEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIToastComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UIToastComponent, "ui-toast", never, { "message": { "alias": "message"; "required": false; }; }, { "animationEvent": "animationEvent"; }, never, never, true, never>;
}

declare class ToastInjector implements Injector {
    private _toastRef;
    private _parentInjector;
    constructor(_toastRef: UIToastRef<any>, _parentInjector: Injector);
    get(token: ProviderToken<any>, notFoundValue?: any): any;
}

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

interface PageNumber {
    number: number;
    text: string;
    active: boolean;
}
declare class UIPagination implements OnInit, OnDestroy {
    private _darkThemeService;
    private _subscription;
    _currentPageNumber: number;
    private _total;
    private _countPerPage;
    private _max;
    pageNumberList: PageNumber[];
    totalPages: number;
    isDarkTheme: boolean;
    pageChange: EventEmitter<number>;
    set currentPage(page: number);
    get currentPage(): number;
    set total(total: number);
    set countPerPage(count: number);
    set max(max: number);
    constructor(_darkThemeService: DarkThemeService);
    ngOnDestroy(): void;
    ngOnInit(): void;
    onClickPage(page: PageNumber): void;
    prevPage(): void;
    nextPage(): void;
    private isUndefined;
    private makePage;
    private updatePageNumberList;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIPagination, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UIPagination, "ui-pagination", never, { "currentPage": { "alias": "currentPage"; "required": false; }; "total": { "alias": "total"; "required": false; }; "countPerPage": { "alias": "countPerPage"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
}

declare class UIPaginationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UIPaginationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UIPaginationModule, never, [typeof i1.CommonModule, typeof UIPagination], [typeof UIPagination]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UIPaginationModule>;
}

declare const SCROLL_DISTANCE = 10;
declare class UIScrollbar implements AfterViewInit, OnChanges, OnDestroy, OnInit {
    private _darkThemeService;
    private _subscription;
    private _isDrag;
    /**
     * when _isDrag is false, we need to smoothly move the scrollbarThumb to our final y position.
     * so we need to store current point position. this position may be updated by mousemove event
     */
    private _finalY;
    private _timer;
    private _dragStartOffset;
    private _isDraging;
    contentHeight: number;
    set scrollPosition(percentage: number);
    scrollChange: EventEmitter<number>;
    scrollbarRect: ClientRect;
    showScrollbar: boolean;
    scrollbarThumbHeight: number;
    scrollbarThumbTop: number;
    isDarkTheme: boolean;
    scrollbar: ElementRef;
    constructor(_darkThemeService: DarkThemeService);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private smoothScrollTo;
    private updateScrollBarThumbPosition;
    private determineScrollbar;
    private scrollTo;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIScrollbar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UIScrollbar, "ui-scrollbar", never, { "contentHeight": { "alias": "contentHeight"; "required": false; }; "scrollPosition": { "alias": "scrollPosition"; "required": false; }; }, { "scrollChange": "scrollChange"; }, never, never, true, never>;
}

declare class UIScrollbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UIScrollbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UIScrollbarModule, never, [typeof i1.CommonModule, typeof UIScrollbar], [typeof UIScrollbar]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UIScrollbarModule>;
}

declare class RowItem {
    date: Date;
    rowHeightPercent: number;
    label: string;
    pos: string;
}
declare class Marker {
    items: RowItem[];
    totalHeightPercent: number;
    showMarker: boolean;
}
declare class Label {
    label: string;
    leadDate: Date;
    markers: Marker[];
    totalHeightPercent: number;
    showLabel: boolean;
}
declare class RenderEntity {
    isLabel: boolean;
    label: string;
    top: string;
    constructor(isLabel: boolean, label: string, top: string);
}
declare const LABEL_MARGIN = 15;
declare const MARKER_MARGIN = 8;
/**
 * Minimum speed to show tooltip when scroll
 * @type {number} unit is rows/sec
 */
declare const MIN_VELOCITY = 4;
declare const TOOLTIP_FADE_TIME = 800;
declare class UITimeLineMeter implements AfterViewInit, OnInit, OnDestroy, OnChanges {
    private _darkThemeService;
    private _subscription;
    private _scrollPosition;
    private _onContentScroll;
    private _itemList;
    private _meterWidth;
    private _meterHeight;
    private _isBuilding;
    private _isInMeasure;
    contentScrollState: SCROLL_STATE;
    scrollPercentage: number;
    /**
     * the scrollable content height
     */
    contentHeight: number;
    availableHeight: number;
    toolTipHeight: number;
    labelList: Label[];
    /**
     * we maintain this list which only contains label an mark whose showLabel or showMarker property is true.
     * this approach could reduce DOM elements and increase speed and save memory
     */
    renderEntityList: RenderEntity[];
    showTooltip: boolean;
    floatMarkPos: string;
    pointedItem: RowItem;
    disableDarkTheme: boolean;
    isDarkTheme: boolean;
    meter: ElementRef;
    container: ElementRef;
    renderWrapper: ElementRef;
    timestampList: number[];
    /**
     * labelSpan describes what span of time should a label be displayed.
     * The labels display may vary base on timestamp list, height of each row and height of meter.
     * But the minimal time span of the label is not less than this value.
     * @type {string}
     */
    labelSpan: 'year' | 'month' | 'day' | 'hour';
    /**
     * markSpan should always smaller than labelSpan
     * @type {string}
     */
    markSpan: 'month' | 'week' | 'day' | 'hour';
    showMarker: boolean;
    /**
     * if rowHeight is set, meter will use this height for all rows.
     * mark on meter will be evenly placed.
     * If you use InfiniteList as content, row height must be set.
     */
    rowHeight: number;
    set rowHeightList(list: number[]);
    constructor(_darkThemeService: DarkThemeService);
    ngOnInit(): void;
    /**
     * This method is called by content component to update its
     * @param scrollPercentage should be percentage digital of scroll y position
     */
    setScrollY(scrollPercentage: number): void;
    onScrollbarChange(scrollPercentage: number): void;
    /**
     * scroll position is a percentage float number.
     * content component should calculate actual scrollY multiply its own height
     * @returns {Observable<number>}
     */
    get scrollPosition(): Observable<number>;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * to increase performance. we only render a list of entity which can be both label and marker but only those to be shown
     * will be in this list.
     */
    private makeRenderEntity;
    /**
     * measure the marker
     * @param computedFontSize
     */
    private measureMarker;
    private measureTooltipSize;
    /**
     * Once we have labelList ready. we need to measure the meter height and width. then if height is available. we need to decide
     * which label and marker should be show depending on their height and our rule.
     */
    private measure;
    /**
     * build our labelList to store the label, mark tree. each row item is group to markers and then markers group
     * to labels depending on their label time span and marker time span.
     * this method will be called in two situation:
     * - rowHeight and timestampList are all available. then build _itemList base on these two information. in this case,
     *  every row has some height. this is usually happened when you use InfiniteList with this component.
     * - rowHeightList is set by content child, this is the case when you use ScrollableContent component with this component.
     *  In this case, _itemList has already built.
     */
    private buildMeter;
    private isInSameSpan;
    /**
     * get label string represent for given date in label time span
     * TODO: need i18n compatibility for label.
     * @param date the date used to get label.
     * @param needParentUnit sometimes, a label in certain time span is reset from the beginning. to give enough information
     * a parent time span will added to this label. e.g. labelSpan = 'hour', we have a series of label 11, 12, 1, 2... 11,
     * we know that second 11 is the 11hrs of second day. But add the day will be more informative.
     * @returns {string}
     */
    private getLabel;
    private getTooltipLabel;
    /**
     * This method is called every time a user click or move on this meter.
     * A popover should be shown contain current pointed item date (up to marker span accuracy).
     * then content component should be scroll to corresponding position.
     * @param pos
     */
    private scrollTo;
    /**
     * update pointedItem
     * @param percentage
     */
    private updatePointedItem;
    private updateCursorPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<UITimeLineMeter, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UITimeLineMeter, "ui-timeline-meter", never, { "disableDarkTheme": { "alias": "disableDarkTheme"; "required": false; }; "timestampList": { "alias": "timestampList"; "required": false; }; "labelSpan": { "alias": "labelSpan"; "required": false; }; "markSpan": { "alias": "markSpan"; "required": false; }; "showMarker": { "alias": "showMarker"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class UIScrollableContent implements AfterViewInit, OnDestroy, DoCheck {
    private _timelineMeter;
    private _subcription;
    scrollableContent: ElementRef;
    private _contentHeight;
    private _containerHeight;
    constructor(_timelineMeter: UITimeLineMeter);
    ngAfterViewInit(): void;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIScrollableContent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UIScrollableContent, "ui-scrollable-content", never, {}, {}, never, never, true, never>;
}

declare class UITimelineMeterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UITimelineMeterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UITimelineMeterModule, never, [typeof i1.CommonModule, typeof UIScrollbarModule, typeof UITimeLineMeter, typeof UIScrollableContent], [typeof UITimeLineMeter, typeof UIScrollableContent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UITimelineMeterModule>;
}

declare const SCROLL_STOP_TIME_THRESHOLD = 200;
declare class InfiniteList implements AfterViewInit, OnDestroy {
    private _timelineMeter;
    private _holderHeight;
    private _containerWidth;
    private _containerHeight;
    private _subscription;
    private _scrollStateChange;
    private _scrollPosition;
    private _sizeChange;
    private ignoreScrollEvent;
    private _initialScrollTop;
    currentScrollState: SCROLL_STATE;
    listContainer: ElementRef;
    scrollbarStyle: string;
    scrollbarWidth: number;
    set holderHeight(height: number);
    get holderHeight(): number;
    get holderHeightInPx(): string;
    /**
     * scroll state change
     * @returns {Observable<SCROLL_STATE>}
     */
    get scrollStateChange(): Observable<SCROLL_STATE>;
    /**
     * current scroll position.
     * @type {number}
     */
    get scrollPosition(): Observable<number>;
    /**
     * list container width and height.
     */
    get sizeChange(): Observable<number[]>;
    rowHeight: number;
    set newScrollPosition(p: number);
    /**
     * UITimelineMeter is optional injection. when this component used inside a UITimelineMeter.
     * it is responsible to update the scrollY
     * @param _timelineMeter
     */
    constructor(_timelineMeter: UITimeLineMeter);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    measure(): {
        width: number;
        height: number;
    };
    requestMeasure(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InfiniteList, [{ optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InfiniteList, "infinite-list", never, { "rowHeight": { "alias": "rowHeight"; "required": false; }; "newScrollPosition": { "alias": "newScrollPosition"; "required": false; }; }, { "scrollPosition": "scrollPosition"; }, never, ["*"], true, never>;
}
declare enum SCROLL_STATE {
    SCROLLING = 0,
    IDLE = 1
}
declare function getScrollBarWidth(): number;

type InfiniteDataBucket = {
    start: number;
    end: number;
    filled?: boolean;
    fetching?: boolean;
};
declare class InfiniteDataBucketsStub {
    buckets: InfiniteDataBucket[];
    context: any;
    onLoadBucket: (bucketIndex: number) => Promise<Iterable<any>>;
    constructor(buckets: InfiniteDataBucket[], context: any, onLoadBucket: (bucketIndex: number) => Promise<Iterable<any>>);
    loadBucket(bucketIndex: number): Promise<Iterable<any>>;
}

declare class Recycler {
    private limit;
    private scrapViews;
    getView(position: number): ViewRef | null;
    recycleView(position: number, view: ViewRef): void;
    /**
     * scrap view count should not exceed the number of current attached views.
     */
    pruneScrapViews(): void;
    setScrapViewsLimit(limit: number): void;
    clean(): void;
}
declare class InfiniteRow {
    $implicit: any;
    index: number;
    count: number;
    isInitialized: boolean;
    constructor($implicit: any, index: number, count: number, isInitialized: boolean);
    get first(): boolean;
    get last(): boolean;
    get even(): boolean;
    get odd(): boolean;
}
declare class InfiniteForOf<T> implements OnChanges, DoCheck, OnInit, OnDestroy {
    private _infiniteList;
    private _differs;
    private _template;
    private _viewContainerRef;
    private _differ;
    private _trackByFn;
    private _subscription;
    /**
     * scroll offset of y-axis in pixel
     */
    private _scrollY;
    /**
     * first visible item index in collection
     */
    private _firstItemPosition;
    /**
     * last visible item index in collection
     */
    private _lastItemPosition;
    private _containerWidth;
    private _containerHeight;
    /**
     * when this value is true, a full clean layout is required, every element must be reposition
     * @type {boolean}
     * @private
     */
    private _invalidate;
    /**
     * when this value is true, a layout is in process
     * @type {boolean}
     * @private
     */
    private _isInLayout;
    private _isInMeasure;
    private _pendingMeasurement;
    private _collection;
    private _recycler;
    private _bucketsStub;
    infiniteForOf: NgIterable<T>;
    set infiniteForTrackBy(fn: TrackByFunction<T>);
    get infiniteForTrackBy(): TrackByFunction<T>;
    set infiniteForWithBucket(stub: InfiniteDataBucketsStub);
    get infiniteForWithBucket(): InfiniteDataBucketsStub;
    set infiniteForTemplate(value: TemplateRef<InfiniteRow>);
    get buckets(): InfiniteDataBucket[];
    get length(): number;
    constructor(_infiniteList: InfiniteList, _differs: IterableDiffers, _template: TemplateRef<InfiniteRow>, _viewContainerRef: ViewContainerRef);
    ngOnChanges(changes: SimpleChanges): void;
    ngDoCheck(): void;
    private applyChanges;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private requestMeasure;
    private requestLayout;
    private measure;
    private layout;
    private calculateScrapViewsLimit;
    private insertViews;
    private applyStyles;
    private dispatchLayout;
    private findPositionInRange;
    private getView;
    private findBucketIndexByPosition;
    private loadBucket;
    static ɵfac: i0.ɵɵFactoryDeclaration<InfiniteForOf<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<InfiniteForOf<any>, "[infiniteFor][infiniteForOf]", never, { "infiniteForOf": { "alias": "infiniteForOf"; "required": false; }; "infiniteForTrackBy": { "alias": "infiniteForTrackBy"; "required": false; }; "infiniteForWithBucket": { "alias": "infiniteForWithBucket"; "required": false; }; "infiniteForTemplate": { "alias": "infiniteForTemplate"; "required": false; }; }, {}, never, never, true, never>;
}
declare function getTypeNameForDebugging(type: any): string;

declare class UIInfiniteListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UIInfiniteListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UIInfiniteListModule, never, [typeof i1.CommonModule, typeof InfiniteForOf, typeof InfiniteList], [typeof InfiniteForOf, typeof InfiniteList]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UIInfiniteListModule>;
}

declare class UIDropdown implements OnInit, OnDestroy {
    private _element;
    private platformId;
    private _subscription;
    private _menuOpen;
    private _timestamp;
    /**
     * determine what event should trigger dropdown open.
     * @type {string}
     */
    uiDropdown: 'click' | 'hover';
    stopPropagation: boolean;
    set menuOpen(value: boolean);
    get menuOpen(): boolean;
    constructor(_element: ElementRef, platformId: object);
    onHostClick(event: MouseEvent): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIDropdown, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UIDropdown, "[uiDropdown]", never, { "uiDropdown": { "alias": "uiDropdown"; "required": false; }; "stopPropagation": { "alias": "stopPropagation"; "required": false; }; }, {}, never, never, true, never>;
}

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

declare class UIToggleChange {
    /** The source UIToggle of the event. */
    source: UIToggle;
    /** The new `checked` value of the UIToggle. */
    checked: boolean;
    constructor(
    /** The source UIToggle of the event. */
    source: UIToggle, 
    /** The new `checked` value of the UIToggle. */
    checked: boolean);
}
declare const UI_TOGGLE_VALUE_ACCESSOR: ExistingProvider;
declare class UIToggle implements ControlValueAccessor, OnInit, OnDestroy {
    private _darkThemeService;
    private _subscription;
    ready: boolean;
    isDisabled: boolean;
    checked: boolean;
    value: any;
    inputId: string;
    text: string;
    readonly change: EventEmitter<UIToggleChange>;
    isDarkTheme: boolean;
    private _onChangeHandler;
    constructor(_darkThemeService: DarkThemeService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    toggle(): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onInputChange(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIToggle, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UIToggle, "ui-toggle", never, { "value": { "alias": "value"; "required": false; }; "inputId": { "alias": "id"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class UIToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UIToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UIToggleModule, never, [typeof i1.CommonModule, typeof UIToggle], [typeof UIToggle]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UIToggleModule>;
}

declare class UIPopoverRef<T> {
    private _appRef;
    placement: Popper.Placement;
    private _popper;
    private _disposeCallback;
    private _afterClosed;
    componentInstance: T;
    constructor(_appRef: ApplicationRef, placement: Popper.Placement);
    afterClosed(): Observable<any>;
    applyProps(props: {
        [prop: string]: any;
    }): void;
    attach(refElement: Element, componentRef: ComponentRef<T>): void;
    close(result?: any): void;
    updatePosition(): void;
    private appendToBody;
    /** Gets the root HTMLElement for an instantiated component. */
    private getComponentRootNode;
}

declare class UIPopover {
    private _appRef;
    private _injector;
    constructor(_appRef: ApplicationRef, _injector: Injector);
    createPopover<T>(refElement: Element, PopoverComponent: Type<T>, placement?: Popper.Placement): UIPopoverRef<T>;
    createPopoverFromRegistry(refElement: Element, registeredPopover: string, placement?: Popper.Placement): UIPopoverRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIPopover, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UIPopover>;
}

declare class UIPopoverDirective implements OnInit, OnDestroy {
    private _element;
    private _popoverService;
    private _subscription;
    private _popoverRef;
    popover: string;
    popoverProp: {
        [prop: string]: any;
    };
    trigger: 'alwaysOn' | 'click';
    placement: Popper.Placement;
    onClose: EventEmitter<any>;
    constructor(_element: ElementRef, _popoverService: UIPopover);
    onClickListener(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private initPopover;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIPopoverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UIPopoverDirective, "[ui-popover]", never, { "popover": { "alias": "popover"; "required": false; }; "popoverProp": { "alias": "popoverProp"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; }, { "onClose": "onClose"; }, never, never, true, never>;
}

declare abstract class UIPopoverContent {
    protected popoverRef: UIPopoverRef<UIPopoverContent>;
    protected constructor(popoverRef: UIPopoverRef<UIPopoverContent>);
    static ɵfac: i0.ɵɵFactoryDeclaration<UIPopoverContent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UIPopoverContent, never, never, {}, {}, never, never, true, never>;
}

declare class BasicPopoverComponent extends UIPopoverContent implements AfterViewInit, OnInit, OnDestroy {
    private _darkThemeService;
    private _subscription;
    title: string;
    content: string;
    clickToClose: boolean;
    triggeredBy: 'click' | 'alwaysOn';
    zIndex: number;
    placement: string;
    isDarkTheme: boolean;
    constructor(popoverRef: UIPopoverRef<BasicPopoverComponent>, _darkThemeService: DarkThemeService);
    ngOnInit(): void;
    onPopoverClick(event: Event): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BasicPopoverComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BasicPopoverComponent, "ui-basic-popover", never, { "title": { "alias": "title"; "required": false; }; "content": { "alias": "content"; "required": false; }; "clickToClose": { "alias": "clickToClose"; "required": false; }; "triggeredBy": { "alias": "triggeredBy"; "required": false; }; }, {}, never, never, true, never>;
}

declare const registry: Map<string, Type<any>>;
/**
 * Decorator for register the popover content component
 * @param {string} name
 * @constructor
 */
declare function Popover(name: string): <T>(target: {
    new (...args: any[]): T;
}) => new (...args: any[]) => T;

declare class UIPopoverModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UIPopoverModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UIPopoverModule, never, [typeof i1.CommonModule, typeof UIPopoverDirective, typeof BasicPopoverComponent], [typeof UIPopoverDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UIPopoverModule>;
}

interface ObservableStub {
    target: Element;
    callback(rect: ClientRect): void;
    unobserveOnVisible: boolean;
}
declare class UIResponsiveService {
    private _observer;
    private _observableStubList;
    constructor(platformId: object);
    intersectionCallback(entries: IntersectionObserverEntry[]): void;
    observe(stub: ObservableStub): void;
    unobserve(stub: ObservableStub): void;
    private getStub;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIResponsiveService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UIResponsiveService>;
}

interface IResponsiveGenerateSrc {
    /**
     * return an url for the real src, the width or height may be 0 that means it will be automatic to keep ratio.
     * @param src
     * @param width
     * @param height
     * @param originalWidth
     * @param originalHeight
     * @param ratio the client height/width ratio, can be 0 means the width or height is 0
     */
    makeRespSrc(src: string, width: number, height: number, originalWidth: number, originalHeight: number, ratio: number): string;
}
declare class ResponsiveGenerateSrcService implements IResponsiveGenerateSrc {
    makeRespSrc(src: string, width: number, height: number, originalWidth: number, originalHeight: number, ratio: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsiveGenerateSrcService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResponsiveGenerateSrcService>;
}
declare class RoundGenerateSrcService implements IResponsiveGenerateSrc {
    makeRespSrc(src: string, width: number, height: number, originalWidth: number, originalHeight: number, ratio: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<RoundGenerateSrcService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RoundGenerateSrcService>;
}

interface ResponsiveDimension {
    width: string;
    height: string;
    originalWidth: number;
    originalHeight: number;
}
/**
 * This directive will let a normal HTMLImageElement load a resized image from source url according to its current dimension.
 * It use different approach to decide the dimension depends on `dimension` property.
 * If `dimension` property is not defined or width and height are both set to auto, it will use IntersectionObserver to measure
 * the actual dimension when image is visible in viewport.
 * Otherwise, it will calculate the dimension base on width and height
 * The src will be set to {originalSrc}?size={width}x{height}
 * - originalSrc is the source url of the image
 * - width is calculated or measured width
 * - height is calculated or measured height
 */
declare class UIResponsiveImage implements OnInit, OnChanges, OnDestroy {
    private _element;
    private _responsiveService;
    private _changeDetector;
    private _srcGeneratorService;
    private _src;
    private _respSrc;
    private _width;
    private _height;
    set originalSrc(url: string);
    dimension: ResponsiveDimension;
    get src(): string;
    imageLoad: EventEmitter<Event>;
    imageError: EventEmitter<Event>;
    observableStub: ObservableStub;
    constructor(_element: ElementRef, _responsiveService: UIResponsiveService, _changeDetector: ChangeDetectorRef, _srcGeneratorService: IResponsiveGenerateSrc);
    onLoad(event: Event): void;
    onError(event: Event): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private dimensionChange;
    private needMeasure;
    static getPx(dimen: string): number;
    private makeRespSrc;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIResponsiveImage, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<UIResponsiveImage, "img[originalSrc]", never, { "originalSrc": { "alias": "originalSrc"; "required": false; }; "dimension": { "alias": "dimension"; "required": false; }; }, { "imageLoad": "imageLoad"; "imageError": "imageError"; }, never, never, true, never>;
}

interface ResponsiveWrapperSize {
    /**
     * can be rem, em, pixel, %, vw, auto
     */
    width?: string;
    /**
     * can be rem, em, pixel, %, vh, auto
     */
    height?: string;
    /**
     * A value represents height / width
     * If ratio is used, width must have value and cannot be auto,
     * and height will be ignored.
     */
    ratio?: number;
    /**
     * the image original width and height in pixel
     */
    originalWidth: number;
    originalHeight: number;
}
declare const DEFAULT_HIDDEN_OPACITY = 0.01;
declare class UIResponsiveImageWrapper {
    dimension: ResponsiveDimension;
    src: string;
    display: string;
    set size(s: ResponsiveWrapperSize);
    background: string;
    hostWidth: string;
    hostHeight: string;
    hostPaddingBottom: string;
    imageWidth: string;
    imageHeight: string;
    imagePosition: string;
    imageOpacity: number;
    imageLoad: EventEmitter<Event>;
    imageError: EventEmitter<Event>;
    onLoad(event: Event): void;
    onError(event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UIResponsiveImageWrapper, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UIResponsiveImageWrapper, "ui-responsive-image", never, { "src": { "alias": "src"; "required": false; }; "display": { "alias": "display"; "required": false; }; "size": { "alias": "size"; "required": false; }; "background": { "alias": "background"; "required": false; }; }, { "imageLoad": "imageLoad"; "imageError": "imageError"; }, never, never, true, never>;
}

declare const SRC_GENERATOR_SERVICE = "SRC_GENERATOR_SERVICE";

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

declare class UIModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UIModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UIModule, never, [typeof UIDialogModule, typeof UIToastModule, typeof UIPaginationModule, typeof UIInfiniteListModule, typeof UITimelineMeterModule, typeof UIScrollbarModule, typeof UIDropdownModule, typeof UIToggleModule, typeof UIPopoverModule, typeof UIResponsiveImageModule], [typeof UIDialogModule, typeof UIToastModule, typeof UIPaginationModule, typeof UIInfiniteListModule, typeof UITimelineMeterModule, typeof UIScrollbarModule, typeof UIDropdownModule, typeof UIToggleModule, typeof UIPopoverModule, typeof UIResponsiveImageModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UIModule>;
}

export { BasicPopoverComponent, DARK_THEME, DEFAULT_HIDDEN_OPACITY, DarkThemeService, InfiniteDataBucketsStub, InfiniteForOf, InfiniteList, InfiniteRow, LABEL_MARGIN, LIGHT_THEME, LONG_TOAST, Label, MARKER_MARGIN, MIN_VELOCITY, Marker, Popover, Recycler, RenderEntity, ResponsiveGenerateSrcService, RoundGenerateSrcService, RowItem, SCROLL_DISTANCE, SCROLL_STATE, SCROLL_STOP_TIME_THRESHOLD, SHORT_TOAST, SRC_GENERATOR_SERVICE, TOOLTIP_FADE_TIME, ToastInjector, UIDialog, UIDialogConfig, UIDialogContainer, UIDialogModule, UIDialogRef, UIDropdown, UIDropdownModule, UIInfiniteListModule, UIModule, UIPagination, UIPaginationModule, UIPopover, UIPopoverContent, UIPopoverDirective, UIPopoverModule, UIPopoverRef, UIResponsiveImage, UIResponsiveImageModule, UIResponsiveImageWrapper, UIResponsiveService, UIScrollableContent, UIScrollbar, UIScrollbarModule, UITimeLineMeter, UITimelineMeterModule, UIToast, UIToastComponent, UIToastModule, UIToastRef, UIToggle, UIToggleChange, UIToggleModule, UI_TOGGLE_VALUE_ACCESSOR, getScrollBarWidth, getTypeNameForDebugging, registry };
export type { IResponsiveGenerateSrc, InfiniteDataBucket, ObservableStub, PageNumber, ResponsiveDimension, ResponsiveWrapperSize, ThemeName };