import { OnInit, AfterViewChecked, OnDestroy, NgZone, ElementRef, EventEmitter, ChangeDetectorRef } from '@angular/core';
import { Directionality } from '@angular/cdk/bidi';
import { Observable } from 'rxjs';
import { ScrollViewport } from './scroll-viewport';
import { SmoothScrollElement, SmoothScrollManager, SmoothScrollToOptions } from 'ngx-scrollbar/smooth-scroll';
import { ScrollbarAppearance, ScrollbarTrack, ScrollbarPosition, ScrollbarVisibility, NgScrollbarState, ScrollbarPointerEventsMethod } from './ng-scrollbar.model';
import { ScrollbarManager } from './utils/scrollbar-manager';
import * as ɵngcc0 from '@angular/core';
export declare class NgScrollbar implements OnInit, AfterViewChecked, OnDestroy {
    private el;
    private zone;
    private changeDetectorRef;
    private dir;
    private smoothScroll;
    manager: ScrollbarManager;
    private _disabled;
    private _sensorDisabled;
    private _pointerEventsDisabled;
    private _viewportPropagateMouseMove;
    /** Disable custom scrollbar and switch back to native scrollbar */
    get disabled(): boolean;
    set disabled(disabled: boolean);
    /** Whether ResizeObserver is disabled */
    get sensorDisabled(): boolean;
    set sensorDisabled(disabled: boolean);
    /** A flag used to enable/disable the scrollbar thumb dragged event */
    get pointerEventsDisabled(): boolean;
    set pointerEventsDisabled(disabled: boolean);
    /** Enable viewport mousemove event propagation (only when pointerEventsMethod="viewport") */
    get viewportPropagateMouseMove(): boolean;
    set viewportPropagateMouseMove(disabled: boolean);
    /** A class forwarded to scrollable viewport element */
    viewClass: string | undefined;
    /** A class forwarded to the scrollbar track element */
    trackClass: string | undefined;
    /** A class forwarded to the scrollbar thumb element */
    thumbClass: string | undefined;
    /** Minimum scrollbar thumb size */
    minThumbSize: number | undefined;
    /** The duration which the scrolling takes to reach its target when scrollbar rail is clicked */
    trackClickScrollDuration: number | undefined;
    /**
     * Sets the pointer events method
     * Use viewport pointer events  to handle dragging and track click (This makes scrolling work when mouse is over the scrollbar)
     * Use scrollbar pointer events to handle dragging and track click
     */
    pointerEventsMethod: ScrollbarPointerEventsMethod;
    /**
     * Sets the supported scroll track of the viewport, there are 3 options:
     *
     * - `vertical` Use both vertical and horizontal scrollbar
     * - `horizontal` Use both vertical and horizontal scrollbar
     * - `all` Use both vertical and horizontal scrollbar
     */
    track: ScrollbarTrack;
    /**
     * When to show the scrollbar, and there are 3 options:
     *
     * - `native` (default) Scrollbar will be visible when viewport is scrollable like with native scrollbar
     * - `hover` Scrollbars are hidden by default, only visible on scrolling or hovering
     * - `always` Scrollbars are always shown even if the viewport is not scrollable
     */
    visibility: ScrollbarVisibility;
    /**
     *  Sets the appearance of the scrollbar, there are 2 options:
     *
     * - `standard` (default) scrollbar space will be reserved just like with native scrollbar.
     * - `compact` scrollbar doesn't reserve any space, they are placed over the viewport.
     */
    appearance: ScrollbarAppearance;
    /**
     * Sets the position of each scrollbar, there are 4 options:
     *
     * - `native` (Default) Use the default position like in native scrollbar.
     * - `invertY` Inverts vertical scrollbar position
     * - `invertX` Inverts Horizontal scrollbar position
     * - `invertAll` Inverts both scrollbar positions
     */
    position: ScrollbarPosition;
    /** Debounce interval for detecting changes via ResizeObserver */
    sensorDebounce: number | undefined;
    /** Scroll Audit Time */
    scrollAuditTime: number | undefined;
    /** Steam that emits when scrollbar is updated */
    updated: EventEmitter<void>;
    /** Default viewport reference */
    private defaultViewPort;
    /** Custom viewport reference */
    private customViewPort;
    /** Viewport Element */
    viewport: ScrollViewport;
    /** Set of attributes added on the scrollbar wrapper */
    state: NgScrollbarState;
    /** Stream that destroys components' observables */
    private readonly destroyed;
    /** Stream that emits on scroll event */
    scrolled: Observable<any>;
    /** Steam that emits scroll event for vertical scrollbar */
    verticalScrolled: Observable<any>;
    /** Steam that emits scroll event for horizontal scrollbar */
    horizontalScrolled: Observable<any>;
    get nativeElement(): HTMLElement;
    constructor(el: ElementRef, zone: NgZone, changeDetectorRef: ChangeDetectorRef, dir: Directionality, smoothScroll: SmoothScrollManager, manager: ScrollbarManager);
    /**
     * Update local state with each change detection
     */
    private updateState;
    private _updateState;
    private getScrolledByDirection;
    /**
     * Set hovered state if a scrollbar is being hovered
     */
    setHovered(hovered: ScrollbarHovered): void;
    /**
     * Set dragging state if a scrollbar is being dragged
     */
    setDragging(dragging: ScrollbarDragging): void;
    /**
     * Set clicked state if a scrollbar track is being click
     */
    setClicked(scrollbarClicked: boolean): void;
    ngOnInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    /**
     * Update local state and the internal scrollbar controls
     */
    update(): void;
    /**
     * Smooth scroll functions
     */
    scrollTo(options: SmoothScrollToOptions): Promise<void>;
    /**
     * Scroll to element by reference or selector
     */
    scrollToElement(target: SmoothScrollElement, options?: any): Promise<void>;
    static ɵfac: ɵngcc0.ɵɵFactoryDef<NgScrollbar>;
    static ɵcmp: ɵngcc0.ɵɵComponentDefWithMeta<NgScrollbar, "ng-scrollbar", ["ngScrollbar"], {
    "viewClass": "viewClass";
    "trackClass": "trackClass";
    "thumbClass": "thumbClass";
    "minThumbSize": "minThumbSize";
    "trackClickScrollDuration": "trackClickScrollDuration";
    "pointerEventsMethod": "pointerEventsMethod";
    "track": "track";
    "visibility": "visibility";
    "appearance": "appearance";
    "position": "position";
    "sensorDebounce": "sensorDebounce";
    "scrollAuditTime": "scrollAuditTime";
    "disabled": "disabled";
    "sensorDisabled": "sensorDisabled";
    "pointerEventsDisabled": "pointerEventsDisabled";
    "viewportPropagateMouseMove": "viewportPropagateMouseMove";
}, {
    "updated": "updated";
}, ["customViewPort"]>;
}
interface ScrollbarDragging {
    verticalDragging?: boolean;
    horizontalDragging?: boolean;
}
interface ScrollbarHovered {
    verticalHovered?: boolean;
    horizontalHovered?: boolean;
}
export {};

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"ng-scrollbar.d.ts","sources":["ng-scrollbar.d.ts"],"names":[],"mappings":"AAAA;;;;;;;;AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgIA","sourcesContent":["import { OnInit, AfterViewChecked, OnDestroy, NgZone, ElementRef, EventEmitter, ChangeDetectorRef } from '@angular/core';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { Observable } from 'rxjs';\nimport { ScrollViewport } from './scroll-viewport';\nimport { SmoothScrollElement, SmoothScrollManager, SmoothScrollToOptions } from 'ngx-scrollbar/smooth-scroll';\nimport { ScrollbarAppearance, ScrollbarTrack, ScrollbarPosition, ScrollbarVisibility, NgScrollbarState, ScrollbarPointerEventsMethod } from './ng-scrollbar.model';\nimport { ScrollbarManager } from './utils/scrollbar-manager';\nexport declare class NgScrollbar implements OnInit, AfterViewChecked, OnDestroy {\n    private el;\n    private zone;\n    private changeDetectorRef;\n    private dir;\n    private smoothScroll;\n    manager: ScrollbarManager;\n    private _disabled;\n    private _sensorDisabled;\n    private _pointerEventsDisabled;\n    private _viewportPropagateMouseMove;\n    /** Disable custom scrollbar and switch back to native scrollbar */\n    get disabled(): boolean;\n    set disabled(disabled: boolean);\n    /** Whether ResizeObserver is disabled */\n    get sensorDisabled(): boolean;\n    set sensorDisabled(disabled: boolean);\n    /** A flag used to enable/disable the scrollbar thumb dragged event */\n    get pointerEventsDisabled(): boolean;\n    set pointerEventsDisabled(disabled: boolean);\n    /** Enable viewport mousemove event propagation (only when pointerEventsMethod=\"viewport\") */\n    get viewportPropagateMouseMove(): boolean;\n    set viewportPropagateMouseMove(disabled: boolean);\n    /** A class forwarded to scrollable viewport element */\n    viewClass: string | undefined;\n    /** A class forwarded to the scrollbar track element */\n    trackClass: string | undefined;\n    /** A class forwarded to the scrollbar thumb element */\n    thumbClass: string | undefined;\n    /** Minimum scrollbar thumb size */\n    minThumbSize: number | undefined;\n    /** The duration which the scrolling takes to reach its target when scrollbar rail is clicked */\n    trackClickScrollDuration: number | undefined;\n    /**\n     * Sets the pointer events method\n     * Use viewport pointer events  to handle dragging and track click (This makes scrolling work when mouse is over the scrollbar)\n     * Use scrollbar pointer events to handle dragging and track click\n     */\n    pointerEventsMethod: ScrollbarPointerEventsMethod;\n    /**\n     * Sets the supported scroll track of the viewport, there are 3 options:\n     *\n     * - `vertical` Use both vertical and horizontal scrollbar\n     * - `horizontal` Use both vertical and horizontal scrollbar\n     * - `all` Use both vertical and horizontal scrollbar\n     */\n    track: ScrollbarTrack;\n    /**\n     * When to show the scrollbar, and there are 3 options:\n     *\n     * - `native` (default) Scrollbar will be visible when viewport is scrollable like with native scrollbar\n     * - `hover` Scrollbars are hidden by default, only visible on scrolling or hovering\n     * - `always` Scrollbars are always shown even if the viewport is not scrollable\n     */\n    visibility: ScrollbarVisibility;\n    /**\n     *  Sets the appearance of the scrollbar, there are 2 options:\n     *\n     * - `standard` (default) scrollbar space will be reserved just like with native scrollbar.\n     * - `compact` scrollbar doesn't reserve any space, they are placed over the viewport.\n     */\n    appearance: ScrollbarAppearance;\n    /**\n     * Sets the position of each scrollbar, there are 4 options:\n     *\n     * - `native` (Default) Use the default position like in native scrollbar.\n     * - `invertY` Inverts vertical scrollbar position\n     * - `invertX` Inverts Horizontal scrollbar position\n     * - `invertAll` Inverts both scrollbar positions\n     */\n    position: ScrollbarPosition;\n    /** Debounce interval for detecting changes via ResizeObserver */\n    sensorDebounce: number | undefined;\n    /** Scroll Audit Time */\n    scrollAuditTime: number | undefined;\n    /** Steam that emits when scrollbar is updated */\n    updated: EventEmitter<void>;\n    /** Default viewport reference */\n    private defaultViewPort;\n    /** Custom viewport reference */\n    private customViewPort;\n    /** Viewport Element */\n    viewport: ScrollViewport;\n    /** Set of attributes added on the scrollbar wrapper */\n    state: NgScrollbarState;\n    /** Stream that destroys components' observables */\n    private readonly destroyed;\n    /** Stream that emits on scroll event */\n    scrolled: Observable<any>;\n    /** Steam that emits scroll event for vertical scrollbar */\n    verticalScrolled: Observable<any>;\n    /** Steam that emits scroll event for horizontal scrollbar */\n    horizontalScrolled: Observable<any>;\n    get nativeElement(): HTMLElement;\n    constructor(el: ElementRef, zone: NgZone, changeDetectorRef: ChangeDetectorRef, dir: Directionality, smoothScroll: SmoothScrollManager, manager: ScrollbarManager);\n    /**\n     * Update local state with each change detection\n     */\n    private updateState;\n    private _updateState;\n    private getScrolledByDirection;\n    /**\n     * Set hovered state if a scrollbar is being hovered\n     */\n    setHovered(hovered: ScrollbarHovered): void;\n    /**\n     * Set dragging state if a scrollbar is being dragged\n     */\n    setDragging(dragging: ScrollbarDragging): void;\n    /**\n     * Set clicked state if a scrollbar track is being click\n     */\n    setClicked(scrollbarClicked: boolean): void;\n    ngOnInit(): void;\n    ngAfterViewChecked(): void;\n    ngOnDestroy(): void;\n    /**\n     * Update local state and the internal scrollbar controls\n     */\n    update(): void;\n    /**\n     * Smooth scroll functions\n     */\n    scrollTo(options: SmoothScrollToOptions): Promise<void>;\n    /**\n     * Scroll to element by reference or selector\n     */\n    scrollToElement(target: SmoothScrollElement, options?: any): Promise<void>;\n}\ninterface ScrollbarDragging {\n    verticalDragging?: boolean;\n    horizontalDragging?: boolean;\n}\ninterface ScrollbarHovered {\n    verticalHovered?: boolean;\n    horizontalHovered?: boolean;\n}\nexport {};\n"]}