import * as i0 from '@angular/core';
import { AfterViewInit, ElementRef, EventEmitter, ChangeDetectorRef, DestroyRef, Renderer2, AfterContentInit, OnDestroy, TemplateRef, QueryList, EmbeddedViewRef, ViewContainerRef, NgZone, OnInit, OnChanges, SimpleChanges, PipeTransform, ComponentRef, DoCheck, IterableDiffers, IterableDiffer, TrackByFunction, IterableChanges, AfterViewChecked } from '@angular/core';
import { IBaseEventArgs, ThemeToken, IgxTheme, PlatformUtil, CancelableBrowserEventArgs, IToggleView, IgxOverlayService, OverlaySettings, OffsetMode, IgxNavigationService, IgxOverlayOutletDirective, PositionSettings, AutoPositionStrategy, Size, Point, ConnectedFit, DatePartDeltas, DatePart, IPositionStrategy } from 'igniteui-angular/core';
import { NgControl, ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
import { Subject } from 'rxjs';
import { NgForOfContext } from '@angular/common';
import { AnimationBuilder } from '@angular/animations';

declare const IgxBaseButtonType: {
    readonly Flat: "flat";
    readonly Contained: "contained";
    readonly Outlined: "outlined";
};
declare abstract class IgxButtonBaseDirective implements AfterViewInit {
    private _platformUtil;
    element: ElementRef<any>;
    private _viewInit;
    /**
     * Emitted when the button is clicked.
     */
    buttonClick: EventEmitter<any>;
    /**
     * Sets/gets the `role` attribute.
     *
     * @example
     * ```typescript
     * this.button.role = 'navbutton';
     * let buttonRole = this.button.role;
     * ```
     */
    role: string;
    /**
     * @hidden
     * @internal
     */
    onClick(ev: MouseEvent): void;
    /**
     * @hidden
     * @internal
     */
    protected onBlur(): void;
    /**
     * Sets/gets whether the button component is on focus.
     * Default value is `false`.
     * ```typescript
     * this.button.focus = true;
     * ```
     * ```typescript
     * let isFocused =  this.button.focused;
     * ```
     */
    protected focused: boolean;
    /**
      * Enables/disables the button.
      *
      * @example
      * ```html
      * <button igxButton="fab" disabled></button>
      * ```
      */
    disabled: boolean;
    /**
     * @hidden
     * @internal
     */
    get disabledAttribute(): true;
    protected constructor();
    ngAfterViewInit(): void;
    /**
     * @hidden
     * @internal
     */
    protected updateOnKeyUp(event: KeyboardEvent): void;
    /**
     * Returns the underlying DOM element.
     */
    get nativeElement(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxButtonBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxButtonBaseDirective, never, never, { "disabled": { "alias": "disabled"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
    static ngAcceptInputType_disabled: unknown;
}

declare const IgxButtonType: {
    readonly FAB: "fab";
    readonly Flat: "flat";
    readonly Contained: "contained";
    readonly Outlined: "outlined";
};
/**
 * Determines the Button type.
 */
type IgxButtonType = typeof IgxButtonType[keyof typeof IgxButtonType];
/**
 * The Button directive provides the Ignite UI Button functionality to every component that's intended to be used as a button.
 *
 * @igxModule IgxButtonModule
 *
 * @igxParent Data Entry & Display
 *
 * @igxTheme igx-button-theme
 *
 * @igxKeywords button, span, div, click
 *
 * @remarks
 * The Ignite UI Button directive is intended to be used by any button, span or div and turn it into a fully functional button.
 *
 * @example
 * ```html
 * <button type="button" igxButton="outlined">A Button</button>
 * ```
 */
declare class IgxButtonDirective extends IgxButtonBaseDirective {
    private _renderer;
    private static ngAcceptInputType_type;
    /**
     * Called when the button is selected.
     */
    buttonSelected: EventEmitter<IButtonEventArgs>;
    /**
     * @hidden
     * @internal
     */
    _cssClass: string;
    /**
     * @hidden
     * @internal
     */
    private _type;
    /**
     * @hidden
     * @internal
     */
    private _color;
    /**
     * @hidden
     * @internal
     */
    private _label;
    /**
     * @hidden
     * @internal
     */
    private _backgroundColor;
    /**
     * @hidden
     * @internal
     */
    private _selected;
    protected emitSelected(): void;
    /**
     * Gets or sets whether the button is selected.
     * Mainly used in the IgxButtonGroup component and it will have no effect if set separately.
     *
     * @example
     * ```html
     * <button type="button" igxButton="flat" [selected]="button.selected"></button>
     * ```
     */
    set selected(value: boolean);
    get selected(): boolean;
    constructor();
    /**
     * Sets the type of the button.
     *
     * @example
     * ```html
     * <button type="button" igxButton="outlined"></button>
     * ```
     */
    set type(type: IgxButtonType);
    /**
     * Sets the `aria-label` attribute.
     *
     * @example
     *  ```html
     * <button type="button" igxButton="flat" igxLabel="Label"></button>
     * ```
     */
    set label(value: string);
    /**
     * @hidden
     * @internal
     */
    get flat(): boolean;
    /**
     * @hidden
     * @internal
     */
    get contained(): boolean;
    /**
     * @hidden
     * @internal
     */
    get outlined(): boolean;
    /**
     * @hidden
     * @internal
     */
    get fab(): boolean;
    /**
     * @hidden
     * @internal
     */
    select(): void;
    /**
     * @hidden
     * @internal
     */
    deselect(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxButtonDirective, "[igxButton]", never, { "selected": { "alias": "selected"; "required": false; }; "type": { "alias": "igxButton"; "required": false; }; "label": { "alias": "igxLabel"; "required": false; }; }, { "buttonSelected": "buttonSelected"; }, never, never, true, never>;
    static ngAcceptInputType_selected: unknown;
}
interface IButtonEventArgs extends IBaseEventArgs {
    button: IgxButtonDirective;
}

declare const LabelPosition: {
    readonly BEFORE: "before";
    readonly AFTER: "after";
};
type LabelPosition = typeof LabelPosition[keyof typeof LabelPosition];
interface IChangeCheckboxEventArgs extends IBaseEventArgs {
    checked: boolean;
    value?: any;
}
declare class CheckboxBaseDirective implements AfterViewInit {
    protected cdr: ChangeDetectorRef;
    protected themeToken: ThemeToken;
    ngControl: NgControl;
    /**
     * An event that is emitted after the checkbox state is changed.
     * Provides references to the `IgxCheckboxComponent` and the `checked` property as event arguments.
     */
    readonly change: EventEmitter<IChangeCheckboxEventArgs>;
    /**
     * @hidden
     * @internal
     */
    destroy$: Subject<boolean>;
    /**
     * Returns reference to the native checkbox element.
     *
     * @example
     * ```typescript
     * let checkboxElement =  this.component.checkboxElement;
     * ```
     */
    nativeInput: ElementRef;
    /**
     * Returns reference to the native label element.
     * ```typescript
     *
     * @example
     * let labelElement =  this.component.nativeLabel;
     * ```
     */
    nativeLabel: ElementRef;
    cssClass: string;
    disabled: boolean;
    readonly: boolean;
    indeterminate: boolean;
    focused: boolean;
    invalid: boolean;
    get checked(): boolean;
    set checked(value: boolean);
    /**
     * Returns reference to the `nativeElement` of the igx-checkbox/igx-switch.
     *
     * @example
     * ```typescript
     * let nativeElement = this.component.nativeElement;
     * ```
     */
    get nativeElement(): any;
    /**
     * Returns reference to the label placeholder element.
     * ```typescript
     *
     * @example
     * let labelPlaceholder =  this.component.placeholderLabel;
     * ```
     */
    placeholderLabel: ElementRef;
    /**
     * Sets/gets the `id` of the checkbox component.
     * If not set, the `id` of the first checkbox component will be `"igx-checkbox-0"`.
     *
     * @example
     * ```html
     * <igx-checkbox id="my-first-checkbox"></igx-checkbox>
     * ```
     * ```typescript
     * let checkboxId =  this.checkbox.id;
     * ```
     */
    id: string;
    /**
     * Sets/gets the id of the `label` element.
     * If not set, the id of the `label` in the first checkbox component will be `"igx-checkbox-0-label"`.
     *
     * @example
     * ```html
     * <igx-checkbox labelId="Label1"></igx-checkbox>
     * ```
     * ```typescript
     * let labelId =  this.component.labelId;
     * ```
     */
    labelId: string;
    /**
     * Sets/gets the `value` attribute.
     *
     * @example
     * ```html
     * <igx-checkbox [value]="'CheckboxValue'"></igx-checkbox>
     * ```
     * ```typescript
     * let value =  this.checkbox.value;
     * ```
     */
    value: any;
    /**
     * Sets/gets the `name` attribute.
     *
     * @example
     * ```html
     * <igx-checkbox name="Checkbox1"></igx-checkbox>
     * ```
     * ```typescript
     * let name =  this.checkbox.name;
     * ```
     */
    name: string;
    /**
     * Sets/gets the value of the `tabindex` attribute.
     *
     * @example
     * ```html
     * <igx-checkbox [tabindex]="1"></igx-checkbox>
     * ```
     * ```typescript
     * let tabIndex =  this.checkbox.tabindex;
     * ```
     */
    tabindex: number;
    /**
     *  Sets/gets the position of the `label`.
     *  If not set, the `labelPosition` will have value `"after"`.
     *
     * @example
     * ```html
     * <igx-checkbox labelPosition="before"></igx-checkbox>
     * ```
     * ```typescript
     * let labelPosition =  this.checkbox.labelPosition;
     * ```
     */
    labelPosition: LabelPosition | string;
    /**
     * Enables/Disables the ripple effect.
     * If not set, `disableRipple` will have value `false`.
     *
     * @example
     * ```html
     * <igx-checkbox [disableRipple]="true"></igx-checkbox>
     * ```
     * ```typescript
     * let isRippleDisabled = this.checkbox.desableRipple;
     * ```
     */
    disableRipple: boolean;
    /**
     * Sets/gets the `aria-labelledby` attribute.
     * If not set, the `aria-labelledby` will be equal to the value of `labelId` attribute.
     *
     * @example
     * ```html
     * <igx-checkbox aria-labelledby="Checkbox1"></igx-checkbox>
     * ```
     * ```typescript
     * let ariaLabelledBy = this.checkbox.ariaLabelledBy;
     * ```
     */
    ariaLabelledBy: string;
    /**
     * Sets/gets the value of the `aria-label` attribute.
     *
     * @example
     * ```html
     * <igx-checkbox aria-label="Checkbox1"></igx-checkbox>
     * ```
     * ```typescript
     * let ariaLabel = this.checkbox.ariaLabel;
     * ```
     */
    ariaLabel: string | null;
    constructor();
    /**
     * Sets/gets whether the checkbox is required.
     * If not set, `required` will have value `false`.
     *
     * @example
     * ```html
     * <igx-checkbox required></igx-checkbox>
     * ```
     * ```typescript
     * let isRequired = this.checkbox.required;
     * ```
     */
    get required(): boolean;
    set required(value: boolean);
    /**
     * @hidden
     * @internal
     */
    ngAfterViewInit(): void;
    /**
     * @hidden
     * @internal
     */
    inputId: string;
    /**
     * @hidden
     */
    protected _onChangeCallback: (_: any) => void;
    /**
     * @hidden
     */
    private _onTouchedCallback;
    /**
     * @hidden
     * @internal
     */
    protected _checked: boolean;
    /**
     * @hidden
     * @internal
     */
    protected theme: IgxTheme;
    /**
     * @hidden
     * @internal
     */
    _required: boolean;
    private elRef;
    protected destroyRef: DestroyRef;
    private setComponentTheme;
    /** @hidden @internal */
    onKeyUp(event: KeyboardEvent): void;
    /** @hidden @internal */
    _onCheckboxClick(event: PointerEvent | MouseEvent): void;
    /**
     * @hidden
     * @internal
     */
    get ariaChecked(): boolean | "mixed";
    /** @hidden @internal */
    _onCheckboxChange(event: Event): void;
    /** @hidden @internal */
    onBlur(): void;
    /** @hidden @internal */
    writeValue(value: boolean): void;
    /** @hidden @internal */
    get labelClass(): string;
    /** @hidden @internal */
    registerOnChange(fn: (_: any) => void): void;
    /** @hidden @internal */
    registerOnTouched(fn: () => void): void;
    /** @hidden @internal */
    setDisabledState(isDisabled: boolean): void;
    /** @hidden @internal */
    getEditElement(): any;
    /**
     * @hidden
     * @internal
     */
    protected updateValidityState(): void;
    /**
     * A function to assign a native validity property of a checkbox.
     * This should be used when there's no ngControl
     *
     * @hidden
     * @internal
     */
    private checkNativeValidity;
    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CheckboxBaseDirective, never, never, { "checked": { "alias": "checked"; "required": false; }; "id": { "alias": "id"; "required": false; }; "labelId": { "alias": "labelId"; "required": false; }; "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; "tabindex": { "alias": "tabindex"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "ariaLabelledBy": { "alias": "aria-labelledby"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "required": { "alias": "required"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
    static ngAcceptInputType_checked: unknown;
    static ngAcceptInputType_disableRipple: unknown;
    static ngAcceptInputType_required: unknown;
}

declare const IgxDividerType: {
    readonly SOLID: "solid";
    readonly DASHED: "dashed";
};
type IgxDividerType = (typeof IgxDividerType)[keyof typeof IgxDividerType];
declare class IgxDividerDirective {
    /**
     * Sets/gets the `id` of the divider.
     * If not set, `id` will have value `"igx-divider-0"`;
     * ```html
     * <igx-divider id="my-divider"></igx-divider>
     * ```
     * ```typescript
     * let dividerId =  this.divider.id;
     * ```
     */
    id: string;
    /**
     * Sets the value of `role` attribute.
     * If not the default value of `separator` will be used.
     */
    role: string;
    /**
     * Sets the type of the divider. The default value
     * is `default`. The divider can also be `dashed`;
     * ```html
     * <igx-divider type="dashed"></igx-divider>
     * ```
     */
    type: IgxDividerType | string;
    get isDashed(): boolean;
    /**
     * If set to `true` and an `inset` value has been provided,
     * the divider will start shrinking from both ends.
     * ```html
     * <igx-divider [middle]="true"></igx-divider>
     * ```
     */
    middle: boolean;
    /**
     * Sets the divider in vertical orientation.
     * ```html
     * <igx-divider [vertical]="true"></igx-divider>
     * ```
     */
    vertical: boolean;
    /**
     * Sets the inset of the divider from the side(s).
     * If the divider attribute `middle` is set to `true`,
     * it will inset the divider on both sides.
     * ```typescript
     * this.divider.inset = '32px';
     * ```
     */
    set inset(value: string);
    /**
     * Gets the current divider inset in terms of
     * inset-inline-start representation as applied to the divider.
     * ```typescript
     * const inset = this.divider.inset;
     * ```
     */
    get inset(): string;
    /**
     * Sets the value of the `inset` attribute.
     * If not provided it will be set to `'0'`.
     * ```html
     * <igx-divider inset="16px"></igx-divider>
     * ```
     */
    private _inset;
    /**
     * A getter that returns `true` if the type of the divider is `default`;
     * ```typescript
     * const isDefault = this.divider.isDefault;
     * ```
     */
    get isSolid(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDividerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxDividerDirective, "igx-divider", never, { "id": { "alias": "id"; "required": false; }; "role": { "alias": "role"; "required": false; }; "type": { "alias": "type"; "required": false; }; "middle": { "alias": "middle"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "inset": { "alias": "inset"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_middle: unknown;
    static ngAcceptInputType_vertical: unknown;
}

interface IDropStrategy {
    dropAction: (drag: IgxDragDirective, drop: IgxDropDirective, atIndex: number) => void;
}
declare class IgxDefaultDropStrategy implements IDropStrategy {
    dropAction(_drag: IgxDragDirective, _drop: IgxDropDirective, _atIndex: number): void;
}
declare class IgxAppendDropStrategy implements IDropStrategy {
    private _renderer;
    constructor(_renderer: Renderer2);
    dropAction(drag: IgxDragDirective, drop: IgxDropDirective, _atIndex: number): void;
}
declare class IgxPrependDropStrategy implements IDropStrategy {
    private _renderer;
    constructor(_renderer: Renderer2);
    dropAction(drag: IgxDragDirective, drop: IgxDropDirective, _atIndex: number): void;
}
declare class IgxInsertDropStrategy implements IDropStrategy {
    private _renderer;
    constructor(_renderer: Renderer2);
    dropAction(drag: IgxDragDirective, drop: IgxDropDirective, atIndex: number): void;
}

declare enum DragScrollDirection {
    UP = 0,
    DOWN = 1,
    LEFT = 2,
    RIGHT = 3
}
declare enum DragDirection {
    VERTICAL = 0,
    HORIZONTAL = 1,
    BOTH = 2
}
interface IgxDragCustomEventDetails {
    startX: number;
    startY: number;
    pageX: number;
    pageY: number;
    owner: IgxDragDirective;
    originalEvent: any;
}
interface IDropBaseEventArgs extends IBaseEventArgs {
    /**
     * Reference to the original event that caused the draggable element to enter the igxDrop element.
     * Can be PointerEvent, TouchEvent or MouseEvent.
     */
    originalEvent: any;
    /** The owner igxDrop directive that triggered this event. */
    owner: IgxDropDirective;
    /** The igxDrag directive instanced on an element that entered the area of the igxDrop element */
    drag: IgxDragDirective;
    /** The data contained for the draggable element in igxDrag directive. */
    dragData: any;
    /** The initial position of the pointer on X axis when the dragged element began moving */
    startX: number;
    /** The initial position of the pointer on Y axis when the dragged element began moving */
    startY: number;
    /**
     * The current position of the pointer on X axis when the event was triggered.
     * Note: The browser might trigger the event with some delay and pointer would be already inside the igxDrop.
     */
    pageX: number;
    /**
     * The current position of the pointer on Y axis when the event was triggered.
     * Note: The browser might trigger the event with some delay and pointer would be already inside the igxDrop.
     */
    pageY: number;
    /**
     * The current position of the pointer on X axis relative to the container that initializes the igxDrop.
     * Note: The browser might trigger the event with some delay and pointer would be already inside the igxDrop.
     */
    offsetX: number;
    /**
     * The current position of the pointer on Y axis relative to the container that initializes the igxDrop.
     * Note: The browser might trigger the event with some delay and pointer would be already inside the igxDrop.
     */
    offsetY: number;
}
interface IDropDroppedEventArgs extends IDropBaseEventArgs {
    /** Specifies if the default drop logic related to the event should be canceled. */
    cancel: boolean;
}
interface IDragBaseEventArgs extends IBaseEventArgs {
    /**
     * Reference to the original event that caused the interaction with the element.
     * Can be PointerEvent, TouchEvent or MouseEvent.
     */
    originalEvent: PointerEvent | MouseEvent | TouchEvent;
    /** The owner igxDrag directive that triggered this event. */
    owner: IgxDragDirective;
    /** The initial position of the pointer on X axis when the dragged element began moving */
    startX: number;
    /** The initial position of the pointer on Y axis when the dragged element began moving */
    startY: number;
    /**
     * The current position of the pointer on X axis when the event was triggered.
     * Note: The browser might trigger the event with some delay and pointer would be already inside the igxDrop.
     */
    pageX: number;
    /**
     * The current position of the pointer on Y axis when the event was triggered.
     * Note: The browser might trigger the event with some delay and pointer would be already inside the igxDrop.
     */
    pageY: number;
}
interface IDragStartEventArgs extends IDragBaseEventArgs {
    /** Set if the the dragging should be canceled. */
    cancel: boolean;
}
interface IDragMoveEventArgs extends IDragStartEventArgs {
    /** The new pageX position of the pointer that the igxDrag will use. It can be overridden to limit dragged element X movement. */
    nextPageX: number;
    /** The new pageX position of the pointer that the igxDrag will use. It can be overridden to limit dragged element Y movement. */
    nextPageY: number;
}
interface IDragGhostBaseEventArgs extends IBaseEventArgs {
    /** The owner igxDrag directive that triggered this event. */
    owner: IgxDragDirective;
    /** Instance to the ghost element that is created when dragging starts. */
    ghostElement: any;
    /** Set if the ghost creation/destruction should be canceled. */
    cancel: boolean;
}
interface IDragCustomTransitionArgs {
    duration?: number;
    timingFunction?: string;
    delay?: number;
}
declare class IgxDragLocation {
    private _pageX;
    private _pageY;
    pageX: number;
    pageY: number;
    constructor(_pageX: any, _pageY: any);
}
declare class IgxDragHandleDirective {
    element: ElementRef<any>;
    baseClass: boolean;
    /**
     * @hidden
     */
    parentDragElement: HTMLElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDragHandleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxDragHandleDirective, "[igxDragHandle]", never, {}, {}, never, never, true, never>;
}
declare class IgxDragIgnoreDirective {
    element: ElementRef<any>;
    baseClass: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDragIgnoreDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxDragIgnoreDirective, "[igxDragIgnore]", never, {}, {}, never, never, true, never>;
}
declare class IgxDragDirective implements AfterContentInit, OnDestroy {
    /**
     * - Save data inside the `igxDrag` directive. This can be set when instancing `igxDrag` on an element.
     * ```html
     * <div [igxDrag]="{ source: myElement }"></div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    set data(value: any);
    get data(): any;
    /**
     * Sets the tolerance in pixels before drag starts.
     * By default the drag starts after the draggable element is moved by 5px.
     * ```html
     * <div igxDrag [dragTolerance]="100">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    dragTolerance: number;
    /**
     * Sets the directions that the element can be dragged.
     * By default it is set to both horizontal and vertical directions.
     * ```html
     * <div igxDrag [dragDirection]="dragDir">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public dragDir = DragDirection.HORIZONTAL;
     * ```
     *
     * @memberof IgxDragDirective
     */
    dragDirection: DragDirection;
    /**
     * A property that provides a way for igxDrag and igxDrop to be linked through channels.
     * It accepts single value or an array of values and evaluates then using strict equality.
     * ```html
     * <div igxDrag [dragChannel]="'odd'">
     *         <span>95</span>
     * </div>
     * <div igxDrop [dropChannel]="['odd', 'irrational']">
     *         <span>Numbers drop area!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    dragChannel: number | string | number[] | string[];
    /**
     * Sets whether the base element should be moved, or a ghost element should be rendered that represents it instead.
     * By default it is set to `true`.
     * If it is set to `false` when dragging the base element is moved instead and no ghost elements are rendered.
     * ```html
     * <div igxDrag [ghost]="false">
     *      <span>Drag Me!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    ghost: boolean;
    /**
     * Sets a custom class that will be added to the `ghostElement` element.
     * ```html
     * <div igxDrag [ghostClass]="'ghostElement'">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    ghostClass: string;
    /**
     * Set styles that will be added to the `ghostElement` element.
     * ```html
     * <div igxDrag [ghostStyle]="{'--ig-size': 'var(--ig-size-small)'}">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    ghostStyle: {};
    /**
     * Specifies a template for the ghost element created when dragging starts and `ghost` is true.
     * By default a clone of the base element the igxDrag is instanced is created.
     * ```html
     * <div igxDrag [ghostTemplate]="customGhost">
     *         <span>Drag Me!</span>
     * </div>
     * <ng-template #customGhost>
     *      <div class="customGhostStyle">
     *          <span>I am being dragged!</span>
     *      </div>
     * </ng-template>
     * ```
     *
     * @memberof IgxDragDirective
     */
    ghostTemplate: TemplateRef<any>;
    /**
     * Sets the element to which the dragged element will be appended.
     * By default it's set to null and the dragged element is appended to the body.
     * ```html
     * <div #hostDiv></div>
     * <div igxDrag [ghostHost]="hostDiv">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    ghostHost: any;
    /**
     * Overrides the scroll container of the dragged element. By default its the window.
     */
    scrollContainer: HTMLElement;
    /**
     * Event triggered when the draggable element drag starts.
     * ```html
     * <div igxDrag (dragStart)="onDragStart()">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public onDragStart(){
     *      alert("The drag has stared!");
     * }
     * ```
     *
     * @memberof IgxDragDirective
     */
    dragStart: EventEmitter<IDragStartEventArgs>;
    /**
     * Event triggered when the draggable element has been moved.
     * ```html
     * <div igxDrag  (dragMove)="onDragMove()">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public onDragMove(){
     *      alert("The element has moved!");
     * }
     * ```
     *
     * @memberof IgxDragDirective
     */
    dragMove: EventEmitter<IDragMoveEventArgs>;
    /**
     * Event triggered when the draggable element is released.
     * ```html
     * <div igxDrag (dragEnd)="onDragEnd()">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public onDragEnd(){
     *      alert("The drag has ended!");
     * }
     * ```
     *
     * @memberof IgxDragDirective
     */
    dragEnd: EventEmitter<IDragBaseEventArgs>;
    /**
     * Event triggered when the draggable element is clicked.
     * ```html
     * <div igxDrag (dragClick)="onDragClick()">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public onDragClick(){
     *      alert("The element has been clicked!");
     * }
     * ```
     *
     * @memberof IgxDragDirective
     */
    dragClick: EventEmitter<IDragBaseEventArgs>;
    /**
     * Event triggered when the drag ghost element is created.
     * ```html
     * <div igxDrag (ghostCreate)="ghostCreated()">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public ghostCreated(){
     *      alert("The ghost has been created!");
     * }
     * ```
     *
     * @memberof IgxDragDirective
     */
    ghostCreate: EventEmitter<IDragGhostBaseEventArgs>;
    /**
     * Event triggered when the drag ghost element is created.
     * ```html
     * <div igxDrag (ghostDestroy)="ghostDestroyed()">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public ghostDestroyed(){
     *      alert("The ghost has been destroyed!");
     * }
     * ```
     *
     * @memberof IgxDragDirective
     */
    ghostDestroy: EventEmitter<IDragGhostBaseEventArgs>;
    /**
     * Event triggered after the draggable element is released and after its animation has finished.
     * ```html
     * <div igxDrag (transitioned)="onMoveEnd()">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     * ```typescript
     * public onMoveEnd(){
     *      alert("The move has ended!");
     * }
     * ```
     *
     * @memberof IgxDragDirective
     */
    transitioned: EventEmitter<IDragBaseEventArgs>;
    /**
     * @hidden
     */
    dragHandles: QueryList<IgxDragHandleDirective>;
    /**
     * @hidden
     */
    dragIgnoredElems: QueryList<IgxDragIgnoreDirective>;
    /**
     * @hidden
     */
    baseClass: boolean;
    /**
     * @hidden
     */
    selectDisabled: boolean;
    /**
     * Gets the current location of the element relative to the page.
     */
    get location(): IgxDragLocation;
    /**
     * Gets the original location of the element before dragging started.
     */
    get originLocation(): IgxDragLocation;
    /**
     * @hidden
     */
    get pointerEventsEnabled(): boolean;
    /**
     * @hidden
     */
    get touchEventsEnabled(): boolean;
    /**
     * @hidden
     */
    get pageX(): number;
    /**
     * @hidden
     */
    get pageY(): number;
    protected get baseLeft(): number;
    protected get baseTop(): number;
    protected get baseOriginLeft(): number;
    protected get baseOriginTop(): number;
    protected set ghostLeft(pageX: number);
    protected get ghostLeft(): number;
    protected set ghostTop(pageY: number);
    protected get ghostTop(): number;
    protected get windowScrollTop(): number;
    protected get windowScrollLeft(): number;
    protected get windowScrollHeight(): number;
    protected get windowScrollWidth(): number;
    /**
     * @hidden
     */
    defaultReturnDuration: string;
    /**
     * @hidden
     */
    ghostElement: any;
    /**
     * @hidden
     */
    animInProgress: boolean;
    protected ghostContext: any;
    protected _startX: number;
    protected _startY: number;
    protected _lastX: number;
    protected _lastY: number;
    protected _dragStarted: boolean;
    /** Drag ghost related properties */
    protected _defaultOffsetX: any;
    protected _defaultOffsetY: any;
    protected _offsetX: any;
    protected _offsetY: any;
    protected _ghostStartX: any;
    protected _ghostStartY: any;
    protected _ghostHostX: number;
    protected _ghostHostY: number;
    protected _dynamicGhostRef: EmbeddedViewRef<any>;
    protected _pointerDownId: any;
    protected _clicked: boolean;
    protected _lastDropArea: any;
    protected _destroy: Subject<boolean>;
    protected _removeOnDestroy: boolean;
    protected _data: any;
    protected _scrollContainer: any;
    protected _originalScrollContainerWidth: number;
    protected _originalScrollContainerHeight: number;
    protected _scrollContainerStep: number;
    protected _scrollContainerStepMs: number;
    protected _scrollContainerThreshold: number;
    protected _containerScrollIntervalId: any;
    private document;
    /**
     * Sets the offset of the dragged element relative to the mouse in pixels.
     * By default it's taking the relative position to the mouse when the drag started and keeps it the same.
     * ```html
     * <div #hostDiv></div>
     * <div igxDrag [ghostOffsetX]="0">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    set ghostOffsetX(value: any);
    get ghostOffsetX(): any;
    /**
     * Sets the offset of the dragged element relative to the mouse in pixels.
     * By default it's taking the relative position to the mouse when the drag started and keeps it the same.
     * ```html
     * <div #hostDiv></div>
     * <div igxDrag [ghostOffsetY]="0">
     *         <span>Drag Me!</span>
     * </div>
     * ```
     *
     * @memberof IgxDragDirective
     */
    set ghostOffsetY(value: any);
    get ghostOffsetY(): any;
    cdr: ChangeDetectorRef;
    element: ElementRef<any>;
    viewContainer: ViewContainerRef;
    zone: NgZone;
    renderer: Renderer2;
    protected platformUtil: PlatformUtil;
    constructor();
    /**
     * @hidden
     */
    ngAfterContentInit(): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * Sets desired location of the base element or ghost element if rended relative to the document.
     *
     * @param newLocation New location that should be applied. It is advised to get new location using getBoundingClientRects() + scroll.
     */
    setLocation(newLocation: IgxDragLocation): void;
    /**
     * Animates the base or ghost element depending on the `ghost` input to its initial location.
     * If `ghost` is true but there is not ghost rendered, it will be created and animated.
     * If the base element has changed its DOM position its initial location will be changed accordingly.
     *
     * @param customAnimArgs Custom transition properties that will be applied when performing the transition.
     * @param startLocation Start location from where the transition should start.
     */
    transitionToOrigin(customAnimArgs?: IDragCustomTransitionArgs, startLocation?: IgxDragLocation): void;
    /**
     * Animates the base or ghost element to a specific target location or other element using transition.
     * If `ghost` is true but there is not ghost rendered, it will be created and animated.
     * It is recommended to use 'getBoundingClientRects() + pageScroll' when determining desired location.
     *
     * @param target Target that the base or ghost will transition to. It can be either location in the page or another HTML element.
     * @param customAnimArgs Custom transition properties that will be applied when performing the transition.
     * @param startLocation Start location from where the transition should start.
     */
    transitionTo(target: IgxDragLocation | ElementRef, customAnimArgs?: IDragCustomTransitionArgs, startLocation?: IgxDragLocation): void;
    /**
     * @hidden
     * Method bound to the PointerDown event of the base element igxDrag is initialized.
     * @param event PointerDown event captured
     */
    onPointerDown(event: any): void;
    /**
     * @hidden
     * Perform drag move logic when dragging and dispatching events if there is igxDrop under the pointer.
     * This method is bound at first at the base element.
     * If dragging starts and after the ghostElement is rendered the pointerId is reassigned it. Then this method is bound to it.
     * @param event PointerMove event captured
     */
    onPointerMove(event: any): void;
    /**
     * @hidden
     * Perform drag end logic when releasing the ghostElement and dispatching drop event if igxDrop is under the pointer.
     * This method is bound at first at the base element.
     * If dragging starts and after the ghostElement is rendered the pointerId is reassigned to it. Then this method is bound to it.
     * @param event PointerUp event captured
     */
    onPointerUp(event: any): void;
    /**
     * @hidden
     * Execute this method whe the pointer capture has been lost.
     * This means that during dragging the user has performed other action like right clicking and then clicking somewhere else.
     * This method will ensure that the drag state is being reset in this case as if the user released the dragged element.
     * @param event Event captured
     */
    onPointerLost(event: any): void;
    /**
     * @hidden
     */
    onTransitionEnd(event: any): void;
    protected detachGhost(): void;
    protected clearGhost(): void;
    /**
     * @hidden
     * Create ghost element - if a Node object is provided it creates a clone of that node,
     * otherwise it clones the host element.
     * Bind all needed events.
     * @param pageX Latest pointer position on the X axis relative to the page.
     * @param pageY Latest pointer position on the Y axis relative to the page.
     * @param node The Node object to be cloned.
     */
    protected createGhost(pageX: any, pageY: any, node?: any): void;
    /**
     * @hidden
     * Dispatch custom igxDragEnter/igxDragLeave events based on current pointer position and if drop area is under.
     */
    protected dispatchDragEvents(pageX: number, pageY: number, originalEvent: any): void;
    /**
     * @hidden
     * Traverse shadow dom in depth.
     */
    protected getFromShadowRoot(elem: any, pageX: any, pageY: any, parentDomElems: any): any[];
    /**
     * @hidden
     * Dispatch custom igxDrop event based on current pointer position if there is last recorder drop area under the pointer.
     * Last recorder drop area is updated in @dispatchDragEvents method.
     */
    protected dispatchDropEvent(pageX: number, pageY: number, originalEvent: any): void;
    /**
     * @hidden
     */
    protected getElementsAtPoint(pageX: number, pageY: number): any;
    /**
     * @hidden
     */
    protected dispatchEvent(target: any, eventName: string, eventArgs: IgxDragCustomEventDetails): void;
    protected getTransformX(elem: any): number;
    protected getTransformY(elem: any): number;
    /** Method setting transformation to the base draggable element. */
    protected setTransformXY(x: number, y: number): void;
    /**
     * Since we are using absolute position to move the ghost, the ghost host might not have position: relative.
     * Combined with position static, this means that the absolute position in the browser is relative to the offsetParent.
     * The offsetParent is pretty much the closes parent that has position: relative, or if no such until it reaches the body.
     * That's why if this is the case, we need to know how much we should compensate for the ghostHost being offset from
     * its offsetParent.
     *
     * OffsetParent can be null in the case of position: fixed applied to the ghost host or display: none. In that case
     * just get the clientRects of the ghost host.
     */
    protected getGhostHostBaseOffsetX(): any;
    protected getGhostHostBaseOffsetY(): any;
    protected getContainerScrollDirection(): DragScrollDirection;
    protected onScrollContainerStep(scrollDir: DragScrollDirection): void;
    protected onScrollContainer(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDragDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxDragDirective, "[igxDrag]", ["drag"], { "data": { "alias": "igxDrag"; "required": false; }; "dragTolerance": { "alias": "dragTolerance"; "required": false; }; "dragDirection": { "alias": "dragDirection"; "required": false; }; "dragChannel": { "alias": "dragChannel"; "required": false; }; "ghost": { "alias": "ghost"; "required": false; }; "ghostClass": { "alias": "ghostClass"; "required": false; }; "ghostStyle": { "alias": "ghostStyle"; "required": false; }; "ghostTemplate": { "alias": "ghostTemplate"; "required": false; }; "ghostHost": { "alias": "ghostHost"; "required": false; }; "scrollContainer": { "alias": "scrollContainer"; "required": false; }; "ghostOffsetX": { "alias": "ghostOffsetX"; "required": false; }; "ghostOffsetY": { "alias": "ghostOffsetY"; "required": false; }; }, { "dragStart": "dragStart"; "dragMove": "dragMove"; "dragEnd": "dragEnd"; "dragClick": "dragClick"; "ghostCreate": "ghostCreate"; "ghostDestroy": "ghostDestroy"; "transitioned": "transitioned"; }, ["dragHandles", "dragIgnoredElems"], never, true, never>;
    static ngAcceptInputType_ghost: unknown;
}
declare class IgxDropDirective implements OnInit, OnDestroy {
    /**
     * - Save data inside the `igxDrop` directive. This can be set when instancing `igxDrop` on an element.
     * ```html
     * <div [igxDrop]="{ source: myElement }"></div>
     * ```
     *
     * @memberof IgxDropDirective
     */
    set data(v: any);
    get data(): any;
    /**
     * A property that provides a way for igxDrag and igxDrop to be linked through channels.
     * It accepts single value or an array of values and evaluates then using strict equality.
     * ```html
     * <div igxDrag [dragChannel]="'odd'">
     *         <span>95</span>
     * </div>
     * <div igxDrop [dropChannel]="['odd', 'irrational']">
     *         <span>Numbers drop area!</span>
     * </div>
     * ```
     *
     * @memberof IgxDropDirective
     */
    dropChannel: number | string | number[] | string[];
    /**
     * Sets a drop strategy type that will be executed when an `IgxDrag` element is released inside
     *  the current drop area. The provided strategies are:
     *  - IgxDefaultDropStrategy - This is the default base strategy and it doesn't perform any actions.
     *  - IgxAppendDropStrategy - Appends the dropped element to last position as a direct child to the `igxDrop`.
     *  - IgxPrependDropStrategy - Prepends the dropped element to first position as a direct child to the `igxDrop`.
     *  - IgxInsertDropStrategy - If the dropped element is released above a child element of the `igxDrop`, it will be inserted
     *      at that position. Otherwise the dropped element will be appended if released outside any child of the `igxDrop`.
     * ```html
     * <div igxDrag>
     *      <span>DragMe</span>
     * </div>
     * <div igxDrop [dropStrategy]="myDropStrategy">
     *         <span>Numbers drop area!</span>
     * </div>
     * ```
     * ```typescript
     * import { IgxAppendDropStrategy } from 'igniteui-angular';
     *
     * export class App {
     *      public myDropStrategy = IgxAppendDropStrategy;
     * }
     * ```
     *
     * @memberof IgxDropDirective
     */
    set dropStrategy(classRef: any);
    get dropStrategy(): any;
    /**
     * Event triggered when dragged element enters the area of the element.
     * ```html
     * <div class="cageArea" igxDrop (enter)="dragEnter()" (igxDragEnter)="onDragCageEnter()" (igxDragLeave)="onDragCageLeave()">
     * </div>
     * ```
     * ```typescript
     * public dragEnter(){
     *     alert("A draggable element has entered the chip area!");
     * }
     * ```
     *
     * @memberof IgxDropDirective
     */
    enter: EventEmitter<IDropBaseEventArgs>;
    /**
     * Event triggered when dragged element enters the area of the element.
     * ```html
     * <div class="cageArea" igxDrop (enter)="dragEnter()" (igxDragEnter)="onDragCageEnter()" (igxDragLeave)="onDragCageLeave()">
     * </div>
     * ```
     * ```typescript
     * public dragEnter(){
     *     alert("A draggable element has entered the chip area!");
     * }
     * ```
     *
     * @memberof IgxDropDirective
     */
    over: EventEmitter<IDropBaseEventArgs>;
    /**
     * Event triggered when dragged element leaves the area of the element.
     * ```html
     * <div class="cageArea" igxDrop (leave)="dragLeave()" (igxDragEnter)="onDragCageEnter()" (igxDragLeave)="onDragCageLeave()">
     * </div>
     * ```
     * ```typescript
     * public dragLeave(){
     *     alert("A draggable element has left the chip area!");
     * }
     * ```
     *
     * @memberof IgxDropDirective
     */
    leave: EventEmitter<IDropBaseEventArgs>;
    /**
     * Event triggered when dragged element is dropped in the area of the element.
     * Since the `igxDrop` has default logic that appends the dropped element as a child, it can be canceled here.
     * To cancel the default logic the `cancel` property of the event needs to be set to true.
     * ```html
     * <div class="cageArea" igxDrop (dropped)="dragDrop()" (igxDragEnter)="onDragCageEnter()" (igxDragLeave)="onDragCageLeave()">
     * </div>
     * ```
     * ```typescript
     * public dragDrop(){
     *     alert("A draggable element has been dropped in the chip area!");
     * }
     * ```
     *
     * @memberof IgxDropDirective
     */
    dropped: EventEmitter<IDropDroppedEventArgs>;
    /**
     * @hidden
     */
    droppable: boolean;
    /**
     * @hidden
     */
    dragover: boolean;
    /**
     * @hidden
     */
    protected _destroy: Subject<boolean>;
    protected _dropStrategy: IDropStrategy;
    private _data;
    element: ElementRef<any>;
    protected _renderer: Renderer2;
    private _zone;
    constructor();
    /**
     * @hidden
     */
    onDragDrop(event: any): void;
    /**
     * @hidden
     */
    ngOnInit(): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * @hidden
     */
    onDragOver(event: any): void;
    /**
     * @hidden
     */
    onDragEnter(event: CustomEvent<IgxDragCustomEventDetails>): void;
    /**
     * @hidden
     */
    onDragLeave(event: any): void;
    protected getWindowScrollTop(): number;
    protected getWindowScrollLeft(): number;
    protected isDragLinked(drag: IgxDragDirective): boolean;
    protected getInsertIndexAt(draggedDir: IgxDragDirective, elementsAtPoint: any[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDropDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxDropDirective, "[igxDrop]", ["drop"], { "data": { "alias": "igxDrop"; "required": false; }; "dropChannel": { "alias": "dropChannel"; "required": false; }; "dropStrategy": { "alias": "dropStrategy"; "required": false; }; }, { "enter": "enter"; "over": "over"; "leave": "leave"; "dropped": "dropped"; }, never, never, true, never>;
}

declare const IGX_DRAG_DROP_DIRECTIVES: readonly [typeof IgxDragDirective, typeof IgxDropDirective, typeof IgxDragHandleDirective, typeof IgxDragIgnoreDirective];

declare class IgxFilterOptions {
    inputValue: string;
    key: string | string[];
    items: any[];
    get_value(item: any, key: string): string;
    formatter(valueToTest: string): string;
    matchFn(valueToTest: string, inputValue: string): boolean;
    metConditionFn(item: any): void;
    overdueConditionFn(item: any): void;
}
declare class IgxFilterDirective implements OnChanges {
    filtering: EventEmitter<any>;
    filtered: EventEmitter<any>;
    filterOptions: IgxFilterOptions;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    private filter;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFilterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxFilterDirective, "[igxFilter]", never, { "filterOptions": { "alias": "igxFilter"; "required": false; }; }, { "filtering": "filtering"; "filtered": "filtered"; }, never, never, true, never>;
}
declare class IgxFilterPipe implements PipeTransform {
    private findMatchByKey;
    transform(items: any[], options: IgxFilterOptions): any[];
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFilterPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<IgxFilterPipe, "igxFilter", true>;
}

declare class IgxFocusDirective {
    private element;
    private comp;
    private control;
    private focusState;
    /**
     * Returns the state of the igxFocus.
     * ```typescript
     * @ViewChild('focusContainer', {read: IgxFocusDirective})
     * public igxFocus: IgxFocusDirective;
     * let isFocusOn = this.igxFocus.focused;
     * ```
     *
     * @memberof IgxFocusDirective
     */
    get focused(): boolean;
    /**
     * Sets the state of the igxFocus.
     * ```html
     * <igx-input-group >
     *  <input #focusContainer igxInput [igxFocus]="true"/>
     * </igx-input-group>
     * ```
     *
     * @memberof IgxFocusDirective
     */
    set focused(val: boolean);
    /**
     * Gets the native element of the igxFocus.
     * ```typescript
     * @ViewChild('focusContainer', {read: IgxFocusDirective})
     * public igxFocus: IgxFocusDirective;
     * let igxFocusNativeElement = this.igxFocus.nativeElement;
     * ```
     *
     * @memberof IgxFocusDirective
     */
    get nativeElement(): any;
    /**
     * Triggers the igxFocus state.
     * ```typescript
     * @ViewChild('focusContainer', {read: IgxFocusDirective})
     * public igxFocus: IgxFocusDirective;
     * this.igxFocus.trigger();
     * ```
     *
     * @memberof IgxFocusDirective
     */
    trigger(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFocusDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxFocusDirective, "[igxFocus]", ["igxFocus"], { "focused": { "alias": "igxFocus"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_focused: unknown;
}

declare class IgxFocusTrapDirective implements AfterViewInit, OnDestroy {
    private elementRef;
    protected platformUtil: PlatformUtil;
    /** @hidden */
    get element(): HTMLElement | null;
    private destroy$;
    private _focusTrap;
    /**
     * Sets whether the Tab key focus is trapped within the element.
     *
     * @example
     * ```html
     * <div igxFocusTrap="true"></div>
     * ```
     */
    set focusTrap(focusTrap: boolean);
    /** @hidden */
    get focusTrap(): boolean;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    private handleTab;
    private getFocusableElements;
    private getFocusedElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFocusTrapDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxFocusTrapDirective, "[igxFocusTrap]", never, { "focusTrap": { "alias": "igxFocusTrap"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_focusTrap: unknown;
}

/**
 * @hidden
 */
declare class IgxScrollInertiaDirective implements OnInit, OnDestroy {
    private element;
    private _zone;
    IgxScrollInertiaDirection: string;
    IgxScrollInertiaScrollContainer: any;
    wheelStep: number;
    inertiaStep: number;
    smoothingStep: number;
    smoothingDuration: number;
    swipeToleranceX: number;
    inertiaDeltaY: number;
    inertiaDeltaX: number;
    inertiaDuration: number;
    private _touchInertiaAnimID;
    private _startX;
    private _startY;
    private _touchStartX;
    private _touchStartY;
    private _lastTouchEnd;
    private _lastTouchX;
    private _lastTouchY;
    private _savedSpeedsX;
    private _savedSpeedsY;
    private _totalMovedX;
    private _offsetRecorded;
    private _offsetDirection;
    private _lastMovedX;
    private _lastMovedY;
    private _nextX;
    private _nextY;
    private parentElement;
    private baseDeltaMultiplier;
    private firefoxDeltaMultiplier;
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * @hidden
     * Function that is called when scrolling with the mouse wheel or using touchpad
     */
    protected onWheel(evt: any): void;
    /**
     * @hidden
     * When there is still room to scroll up/down prevent the parent elements from scrolling too.
     */
    protected preventParentScroll(evt: any, preventDefault: any, nextTop?: number): void;
    /**
     * @hidden
     * Checks if the wheel event would have scrolled an element under the display container
     * in DOM tree so that it can correctly be ignored until that element can no longer be scrolled.
     */
    protected didChildScroll(evt: any, scrollDeltaX: any, scrollDeltaY: any): boolean;
    /**
     * @hidden
     * Function that is called the first moment we start interacting with the content on a touch device
     */
    protected onTouchStart(event: any): boolean;
    /**
     * @hidden
     * Function that is called when we need to scroll the content based on touch interactions
     */
    protected onTouchMove(event: any): void;
    protected onTouchEnd(event: any): void;
    protected _smoothWheelScroll(delta: any): void;
    protected _inertiaInit(speedX: any, speedY: any): void;
    private calcAxisCoords;
    private _scrollTo;
    private _scrollToX;
    private _scrollToY;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxScrollInertiaDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxScrollInertiaDirective, "[igxScrollInertia]", never, { "IgxScrollInertiaDirection": { "alias": "IgxScrollInertiaDirection"; "required": false; }; "IgxScrollInertiaScrollContainer": { "alias": "IgxScrollInertiaScrollContainer"; "required": false; }; "wheelStep": { "alias": "wheelStep"; "required": false; }; "inertiaStep": { "alias": "inertiaStep"; "required": false; }; "smoothingStep": { "alias": "smoothingStep"; "required": false; }; "smoothingDuration": { "alias": "smoothingDuration"; "required": false; }; "swipeToleranceX": { "alias": "swipeToleranceX"; "required": false; }; "inertiaDeltaY": { "alias": "inertiaDeltaY"; "required": false; }; "inertiaDeltaX": { "alias": "inertiaDeltaX"; "required": false; }; "inertiaDuration": { "alias": "inertiaDuration"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DisplayContainerComponent {
    cdr: ChangeDetectorRef;
    _viewContainer: ViewContainerRef;
    _vcr: any;
    _scrollInertia: IgxScrollInertiaDirective;
    cssClass: string;
    notVirtual: boolean;
    scrollDirection: string;
    scrollContainer: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<DisplayContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DisplayContainerComponent, "igx-display-container", never, {}, {}, never, never, true, never>;
}

declare class VirtualHelperBaseDirective implements OnDestroy, AfterViewInit {
    elementRef: ElementRef<HTMLElement>;
    cdr: ChangeDetectorRef;
    protected _zone: NgZone;
    document: Document;
    protected platformUtil: PlatformUtil;
    scrollAmount: number;
    _size: number;
    destroyed: any;
    protected destroy$: Subject<any>;
    private _afterViewInit;
    private _scrollNativeSize;
    private _detached;
    protected renderer: Renderer2;
    protected platformId: Object;
    protected ngZone: NgZone;
    constructor();
    onScroll(event: any): void;
    ngAfterViewInit(): void;
    get nativeElement(): HTMLElement;
    ngOnDestroy(): void;
    calculateScrollNativeSize(): number;
    set size(value: number);
    get size(): number;
    get scrollNativeSize(): number;
    protected get isAttachedToDom(): boolean;
    private toggleClass;
    private updateScrollbarClass;
    protected handleMutations(event: any): void;
    protected restoreScroll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualHelperBaseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VirtualHelperBaseDirective, "[igxVirtualHelperBase]", never, {}, {}, never, never, true, never>;
}

declare class IgxForOfSyncService {
    private _master;
    /**
     * @hidden
     */
    isMaster(directive: IgxGridForOfDirective<any, any[]>): boolean;
    /**
     * @hidden
     */
    setMaster(directive: IgxGridForOfDirective<any, any[]>, forced?: boolean): void;
    /**
     * @hidden
     */
    resetMaster(): void;
    /**
     * @hidden
     */
    sizesCache(dir: string): number[];
    /**
     * @hidden
     */
    chunkSize(dir: string): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxForOfSyncService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxForOfSyncService>;
}
declare class IgxForOfScrollSyncService {
    private _masterScroll;
    setScrollMaster(dir: string, scroll: VirtualHelperBaseDirective): void;
    getScrollMaster(dir: string): VirtualHelperBaseDirective;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxForOfScrollSyncService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxForOfScrollSyncService>;
}

/**
 *  @publicApi
 */
declare class IgxForOfContext<T, U extends T[] = T[]> {
    $implicit: T;
    igxForOf: U;
    index: number;
    count: number;
    constructor($implicit: T, igxForOf: U, index: number, count: number);
    /**
     * A function that returns whether the element is the first or not
     */
    get first(): boolean;
    /**
     * A function that returns whether the element is the last or not
     */
    get last(): boolean;
    /**
     * A function that returns whether the element is even or not
     */
    get even(): boolean;
    /**
     * A function that returns whether the element is odd or not
     */
    get odd(): boolean;
}
/** @hidden @internal */
declare abstract class IgxForOfToken<T, U extends T[] = T[]> {
    abstract igxForOf: U & T[] | null;
    abstract state: IForOfState;
    abstract totalItemCount: number;
    abstract scrollPosition: number;
    abstract chunkLoad: EventEmitter<IForOfState>;
    abstract chunkPreload: EventEmitter<IForOfState>;
    abstract scrollTo(index: number): void;
    abstract getScrollForIndex(index: number, bottom?: boolean): number;
    abstract getScroll(): HTMLElement | undefined;
    abstract igxForItemSize: any;
    abstract igxForContainerSize: any;
    /** @hidden */
    abstract dc: ComponentRef<any>;
}
declare class IgxForOfDirective<T, U extends T[] = T[]> extends IgxForOfToken<T, U> implements OnInit, OnChanges, DoCheck, OnDestroy, AfterViewInit {
    private _viewContainer;
    protected _template: TemplateRef<NgForOfContext<T, i0.NgIterable<T>>>;
    protected _differs: IterableDiffers;
    cdr: ChangeDetectorRef;
    protected _zone: NgZone;
    protected syncScrollService: IgxForOfScrollSyncService;
    protected platformUtil: PlatformUtil;
    protected document: Document;
    /**
     * Sets the data to be rendered.
     * ```html
     * <ng-template igxFor let-item [igxForOf]="data" [igxForScrollOrientation]="'horizontal'"></ng-template>
     * ```
     */
    igxForOf: U & T[] | null;
    /**
     * Sets the property name from which to read the size in the data object.
     */
    igxForSizePropName: any;
    /**
     * Specifies the scroll orientation.
     * Scroll orientation can be "vertical" or "horizontal".
     * ```html
     * <ng-template igxFor let-item [igxForOf]="data" [igxForScrollOrientation]="'horizontal'"></ng-template>
     * ```
     */
    igxForScrollOrientation: string;
    /**
     * Optionally pass the parent `igxFor` instance to create a virtual template scrolling both horizontally and vertically.
     * ```html
     * <ng-template #scrollContainer igxFor let-rowData [igxForOf]="data"
     *       [igxForScrollOrientation]="'vertical'"
     *       [igxForContainerSize]="'500px'"
     *       [igxForItemSize]="'50px'"
     *       let-rowIndex="index">
     *       <div [style.display]="'flex'" [style.height]="'50px'">
     *           <ng-template #childContainer igxFor let-item [igxForOf]="data"
     *               [igxForScrollOrientation]="'horizontal'"
     *               [igxForScrollContainer]="parentVirtDir"
     *               [igxForContainerSize]="'500px'">
     *                   <div [style.min-width]="'50px'">{{rowIndex}} : {{item.text}}</div>
     *           </ng-template>
     *       </div>
     * </ng-template>
     * ```
     */
    igxForScrollContainer: any;
    /**
     * Sets the px-affixed size of the container along the axis of scrolling.
     * For "horizontal" orientation this value is the width of the container and for "vertical" is the height.
     * ```html
     * <ng-template igxFor let-item [igxForOf]="data" [igxForContainerSize]="'500px'"
     *      [igxForScrollOrientation]="'horizontal'">
     * </ng-template>
     * ```
     */
    igxForContainerSize: any;
    /**
     * @hidden
     * @internal
     * Initial chunk size if no container size is passed. If container size is passed then the igxForOf calculates its chunk size
     */
    igxForInitialChunkSize: any;
    /**
     * Sets the px-affixed size of the item along the axis of scrolling.
     * For "horizontal" orientation this value is the width of the column and for "vertical" is the height or the row.
     * ```html
     * <ng-template igxFor let-item [igxForOf]="data" [igxForScrollOrientation]="'horizontal'" [igxForItemSize]="'50px'"></ng-template>
     * ```
     */
    igxForItemSize: any;
    /**
     * An event that is emitted after a new chunk has been loaded.
     * ```html
     * <ng-template igxFor [igxForOf]="data" [igxForScrollOrientation]="'horizontal'" (chunkLoad)="loadChunk($event)"></ng-template>
     * ```
     * ```typescript
     * loadChunk(e){
     * alert("chunk loaded!");
     * }
     * ```
     */
    chunkLoad: EventEmitter<IForOfState>;
    /**
     * @hidden @internal
     * An event that is emitted when scrollbar visibility has changed.
     */
    scrollbarVisibilityChanged: EventEmitter<any>;
    /**
     * An event that is emitted after the rendered content size of the igxForOf has been changed.
     */
    contentSizeChange: EventEmitter<any>;
    /**
     * An event that is emitted after data has been changed.
     * ```html
     * <ng-template igxFor [igxForOf]="data" [igxForScrollOrientation]="'horizontal'" (dataChanged)="dataChanged($event)"></ng-template>
     * ```
     * ```typescript
     * dataChanged(e){
     * alert("data changed!");
     * }
     * ```
     */
    dataChanged: EventEmitter<IForOfDataChangeEventArgs>;
    beforeViewDestroyed: EventEmitter<EmbeddedViewRef<any>>;
    /**
     * An event that is emitted on chunk loading to emit the current state information - startIndex, endIndex, totalCount.
     * Can be used for implementing remote load on demand for the igxFor data.
     * ```html
     * <ng-template igxFor [igxForOf]="data" [igxForScrollOrientation]="'horizontal'" (chunkPreload)="chunkPreload($event)"></ng-template>
     * ```
     * ```typescript
     * chunkPreload(e){
     * alert("chunk is loading!");
     * }
     * ```
     */
    chunkPreload: EventEmitter<IForOfState>;
    /**
     * @hidden
     */
    dc: ComponentRef<DisplayContainerComponent>;
    /**
     * The current state of the directive. It contains `startIndex` and `chunkSize`.
     * state.startIndex - The index of the item at which the current visible chunk begins.
     * state.chunkSize - The number of items the current visible chunk holds.
     * These options can be used when implementing remote virtualization as they provide the necessary state information.
     * ```typescript
     * const gridState = this.parentVirtDir.state;
     * ```
     */
    state: IForOfState;
    protected func: any;
    protected _sizesCache: number[];
    protected scrollComponent: VirtualHelperBaseDirective;
    protected _differ: IterableDiffer<T> | null;
    protected _trackByFn: TrackByFunction<T>;
    protected individualSizeCache: number[];
    /** Internal track for scroll top that is being virtualized */
    protected _virtScrollPosition: number;
    /** If the next onScroll event is triggered due to internal setting of scrollTop */
    protected _bScrollInternal: boolean;
    protected _embeddedViews: Array<EmbeddedViewRef<any>>;
    protected contentResizeNotify: Subject<void>;
    protected contentObserver: ResizeObserver;
    /** Size that is being virtualized. */
    protected _virtSize: number;
    /**
     * @hidden
     */
    protected destroy$: Subject<any>;
    private _totalItemCount;
    private _adjustToIndex;
    /** Maximum size for an element of the browser. */
    private _maxSize;
    /**
     * Ratio for height that's being virtualizaed and the one visible
     * If _virtHeightRatio = 1, the visible height and the virtualized are the same, also _maxSize > _virtHeight.
     */
    private _virtRatio;
    /**
     * The total count of the virtual data items, when using remote service.
     * Similar to the property totalItemCount, but this will allow setting the data count into the template.
     * ```html
     * <ng-template igxFor let-item [igxForOf]="data | async" [igxForTotalItemCount]="count | async"
     *  [igxForContainerSize]="'500px'" [igxForItemSize]="'50px'"></ng-template>
     * ```
     */
    get igxForTotalItemCount(): number;
    set igxForTotalItemCount(value: number);
    /**
     * The total count of the virtual data items, when using remote service.
     * ```typescript
     * this.parentVirtDir.totalItemCount = data.Count;
     * ```
     */
    get totalItemCount(): number;
    set totalItemCount(val: number);
    get displayContainer(): HTMLElement | undefined;
    get virtualHelper(): HTMLElement;
    /**
     * @hidden
     */
    get isRemote(): boolean;
    /**
     *
     * Gets/Sets the scroll position.
     * ```typescript
     * const position = directive.scrollPosition;
     * directive.scrollPosition = value;
     * ```
     */
    get scrollPosition(): number;
    set scrollPosition(val: number);
    /**
     * @hidden
     */
    protected get isRTL(): boolean;
    protected get sizesCache(): number[];
    protected set sizesCache(value: number[]);
    private get _isScrolledToBottom();
    private get _isAtBottomIndex();
    verticalScrollHandler(event: any): void;
    isScrollable(): boolean;
    /**
     * @hidden
     */
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * @hidden @internal
     * Asserts the correct type of the context for the template that `igxForOf` will render.
     *
     * The presence of this method is a signal to the Ivy template type-check compiler that the
     * `IgxForOf` structural directive renders its template with a specific context type.
     */
    static ngTemplateContextGuard<T, U extends T[]>(dir: IgxForOfDirective<T, U>, ctx: any): ctx is IgxForOfContext<T, U>;
    /**
     * @hidden
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * @hidden
     */
    ngDoCheck(): void;
    /**
     * Shifts the scroll thumb position.
     * ```typescript
     * this.parentVirtDir.addScroll(5);
     * ```
     *
     * @param addTop negative value to scroll up and positive to scroll down;
     */
    addScrollTop(add: number): boolean;
    /**
     * Shifts the scroll thumb position.
     * ```typescript
     * this.parentVirtDir.addScroll(5);
     * ```
     *
     * @param add negative value to scroll previous and positive to scroll next;
     */
    addScroll(add: number): boolean;
    /**
     * Scrolls to the specified index.
     * ```typescript
     * this.parentVirtDir.scrollTo(5);
     * ```
     *
     * @param index
     */
    scrollTo(index: number): void;
    /**
     * Scrolls by one item into the appropriate next direction.
     * For "horizontal" orientation that will be the right column and for "vertical" that is the lower row.
     * ```typescript
     * this.parentVirtDir.scrollNext();
     * ```
     */
    scrollNext(): void;
    /**
     * Scrolls by one item into the appropriate previous direction.
     * For "horizontal" orientation that will be the left column and for "vertical" that is the upper row.
     * ```typescript
     * this.parentVirtDir.scrollPrev();
     * ```
     */
    scrollPrev(): void;
    /**
     * Scrolls by one page into the appropriate next direction.
     * For "horizontal" orientation that will be one view to the right and for "vertical" that is one view to the bottom.
     * ```typescript
     * this.parentVirtDir.scrollNextPage();
     * ```
     */
    scrollNextPage(): void;
    /**
     * Scrolls by one page into the appropriate previous direction.
     * For "horizontal" orientation that will be one view to the left and for "vertical" that is one view to the top.
     * ```typescript
     * this.parentVirtDir.scrollPrevPage();
     * ```
     */
    scrollPrevPage(): void;
    /**
     * @hidden
     */
    getColumnScrollLeft(colIndex: any): number;
    /**
     * Returns the total number of items that are fully visible.
     * ```typescript
     * this.parentVirtDir.getItemCountInView();
     * ```
     */
    getItemCountInView(): number;
    /**
     * Returns a reference to the scrollbar DOM element.
     * This is either a vertical or horizontal scrollbar depending on the specified igxForScrollOrientation.
     * ```typescript
     * dir.getScroll();
     * ```
     */
    getScroll(): HTMLElement;
    /**
     * Returns the size of the element at the specified index.
     * ```typescript
     * this.parentVirtDir.getSizeAt(1);
     * ```
     */
    getSizeAt(index: number): number;
    /**
     * @hidden
     * Function that is called to get the native scrollbar size that the browsers renders.
     */
    getScrollNativeSize(): number;
    /**
     * Returns the scroll offset of the element at the specified index.
     * ```typescript
     * this.parentVirtDir.getScrollForIndex(1);
     * ```
     */
    getScrollForIndex(index: number, bottom?: boolean): number;
    /**
     * Returns the index of the element at the specified offset.
     * ```typescript
     * this.parentVirtDir.getIndexAtScroll(100);
     * ```
     */
    getIndexAtScroll(scrollOffset: number): number;
    /**
     * Returns whether the target index is outside the view.
     * ```typescript
     * this.parentVirtDir.isIndexOutsideView(10);
     * ```
     */
    isIndexOutsideView(index: number): boolean;
    /**
     * @hidden
     * Function that recalculates and updates cache sizes.
     */
    recalcUpdateSizes(): void;
    /**
     * @hidden
     * Reset scroll position.
     * Needed in case scrollbar is hidden/detached but we still need to reset it.
     */
    resetScrollPosition(): void;
    /**
     * @hidden
     */
    protected removeScrollEventListeners(): void;
    /**
     * @hidden
     * Function that is called when scrolling vertically
     */
    protected onScroll(event: any): void;
    /**
     * @hidden
     * @internal
     */
    updateScroll(): void;
    protected updateSizes(): void;
    /**
     * @hidden
     */
    protected fixedUpdateAllElements(inScrollTop: number): number;
    /**
     * @hidden
     * The function applies an optimized state change for scrolling down/right employing context change with view rearrangement
     */
    protected moveApplyScrollNext(prevIndex: number): void;
    /**
     * @hidden
     * The function applies an optimized state change for scrolling up/left employing context change with view rearrangement
     */
    protected moveApplyScrollPrev(prevIndex: number): void;
    /**
     * @hidden
     */
    protected getContextIndex(input: any): number;
    /**
     * @hidden
     * Function which updates the passed context of an embedded view with the provided index
     * from the view container.
     * Often, called while handling a scroll event.
     */
    protected updateTemplateContext(context: any, index?: number): void;
    /**
     * @hidden
     * The function applies an optimized state change through context change for each view
     */
    protected fixedApplyScroll(): void;
    /**
     * @hidden
     * @internal
     *
     * Clears focus inside the virtualized container on small scroll swaps.
     */
    protected scrollFocus(node?: HTMLElement): void;
    /**
     * @hidden
     * Function that is called when scrolling horizontally
     */
    protected onHScroll(event: any): void;
    /**
     * Gets the function used to track changes in the items collection.
     * By default the object references are compared. However this can be optimized if you have unique identifier
     * value that can be used for the comparison instead of the object ref or if you have some other property values
     * in the item object that should be tracked for changes.
     * This option is similar to ngForTrackBy.
     * ```typescript
     * const trackFunc = this.parentVirtDir.igxForTrackBy;
     * ```
     */
    get igxForTrackBy(): TrackByFunction<T>;
    /**
     * Sets the function used to track changes in the items collection.
     * This function can be set in scenarios where you want to optimize or
     * customize the tracking of changes for the items in the collection.
     * The igxForTrackBy function takes the index and the current item as arguments and needs to return the unique identifier for this item.
     * ```typescript
     * this.parentVirtDir.igxForTrackBy = (index, item) => {
     *      return item.id + item.width;
     * };
     * ```
     */
    set igxForTrackBy(fn: TrackByFunction<T>);
    /**
     * @hidden
     */
    protected _applyChanges(): void;
    /**
     * @hidden
     */
    protected _calcMaxBrowserSize(): number;
    /**
     * @hidden
     * Recalculates the chunkSize based on current startIndex and returns the new size.
     * This should be called after this.state.startIndex is updated, not before.
     */
    protected _calculateChunkSize(): number;
    /**
     * @hidden
     */
    protected getElement(viewref: any, nodeName: any): any;
    /**
     * @hidden
     */
    protected initSizesCache(items: U): number;
    protected _updateSizeCache(): void;
    /**
     * @hidden
     */
    protected _calcMaxChunkSize(): number;
    /**
     * @hidden
     */
    protected getIndexAt(left: any, set: any): number;
    protected _recalcScrollBarSize(containerSizeInfo?: any): void;
    protected _calcSize(): number;
    protected _recalcOnContainerChange(containerSizeInfo?: any): void;
    /**
     * @hidden
     * Removes an element from the embedded views and updates chunkSize.
     */
    protected removeLastElem(): void;
    /**
     * @hidden
     * If there exists an element that we can create embedded view for creates it, appends it and updates chunkSize
     */
    protected addLastElem(): void;
    /**
     * Recalculates chunkSize and adds/removes elements if need due to the change.
     * this.state.chunkSize is updated in @addLastElem() or @removeLastElem()
     */
    protected applyChunkSizeChange(): void;
    protected _calcVirtualScrollPosition(scrollPosition: number): void;
    protected _getItemSize(item: any, dimension: string): number;
    protected _updateScrollOffset(): void;
    protected _adjustScrollPositionAfterSizeChange(sizeDiff: any): void;
    private getMargin;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxForOfDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxForOfDirective<any, any>, "[igxFor][igxForOf]", never, { "igxForOf": { "alias": "igxForOf"; "required": false; }; "igxForSizePropName": { "alias": "igxForSizePropName"; "required": false; }; "igxForScrollOrientation": { "alias": "igxForScrollOrientation"; "required": false; }; "igxForScrollContainer": { "alias": "igxForScrollContainer"; "required": false; }; "igxForContainerSize": { "alias": "igxForContainerSize"; "required": false; }; "igxForInitialChunkSize": { "alias": "igxForInitialChunkSize"; "required": false; }; "igxForItemSize": { "alias": "igxForItemSize"; "required": false; }; "igxForTotalItemCount": { "alias": "igxForTotalItemCount"; "required": false; }; "igxForTrackBy": { "alias": "igxForTrackBy"; "required": false; }; }, { "chunkLoad": "chunkLoad"; "scrollbarVisibilityChanged": "scrollbarVisibilityChanged"; "contentSizeChange": "contentSizeChange"; "dataChanged": "dataChanged"; "beforeViewDestroyed": "beforeViewDestroyed"; "chunkPreload": "chunkPreload"; }, never, never, true, never>;
}
interface IForOfState extends IBaseEventArgs {
    startIndex?: number;
    chunkSize?: number;
}
/**
 * @deprecated in 19.2.7. Use `IForOfDataChangeEventArgs` instead.
 */
interface IForOfDataChangingEventArgs extends IBaseEventArgs {
    containerSize: number;
    state: IForOfState;
}
interface IForOfDataChangeEventArgs extends IForOfDataChangingEventArgs {
}
declare class IgxGridForOfContext<T, U extends T[] = T[]> extends IgxForOfContext<T, U> {
    igxGridForOf: U;
    constructor($implicit: T, igxGridForOf: U, index: number, count: number);
}
declare class IgxGridForOfDirective<T, U extends T[] = T[]> extends IgxForOfDirective<T, U> implements OnInit, OnChanges, DoCheck {
    protected syncService: IgxForOfSyncService;
    set igxGridForOf(value: U & T[] | null);
    get igxGridForOf(): (U & T[]) | null;
    igxGridForOfUniqueSizeCache: boolean;
    igxGridForOfVariableSizes: boolean;
    /**
     * @hidden
     * @internal
     */
    get sizesCache(): number[];
    /**
     * @hidden
     * @internal
     */
    set sizesCache(value: number[]);
    protected get itemsDimension(): any;
    recalcUpdateSizes(): void;
    /**
     * @hidden @internal
     * An event that is emitted after data has been changed but before the view is refreshed
     */
    dataChanging: EventEmitter<IForOfDataChangeEventArgs>;
    /**
     * @hidden @internal
     * Asserts the correct type of the context for the template that `IgxGridForOfDirective` will render.
     *
     * The presence of this method is a signal to the Ivy template type-check compiler that the
     * `IgxGridForOfDirective` structural directive renders its template with a specific context type.
     */
    static ngTemplateContextGuard<T, U extends T[]>(dir: IgxGridForOfDirective<T, U>, ctx: any): ctx is IgxGridForOfContext<T, U>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * @hidden
     * @internal
     */
    assumeMaster(): void;
    ngDoCheck(): void;
    onScroll(event: any): void;
    onHScroll(scrollAmount: any): void;
    protected getItemSize(item: any): number;
    protected initSizesCache(items: U): number;
    protected _updateSizeCache(changes?: IterableChanges<T>): number;
    protected handleCacheChanges(changes: IterableChanges<T>): number;
    protected addLastElem(): void;
    protected _updateViews(prevChunkSize: any): void;
    protected _applyChanges(): void;
    /**
     * @hidden
     */
    protected _calcMaxChunkSize(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxGridForOfDirective<any, any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxGridForOfDirective<any, any>, "[igxGridFor][igxGridForOf]", never, { "igxGridForOf": { "alias": "igxGridForOf"; "required": false; }; "igxGridForOfUniqueSizeCache": { "alias": "igxGridForOfUniqueSizeCache"; "required": false; }; "igxGridForOfVariableSizes": { "alias": "igxGridForOfVariableSizes"; "required": false; }; }, { "dataChanging": "dataChanging"; }, never, never, true, never>;
    static ngAcceptInputType_igxGridForOfUniqueSizeCache: unknown;
    static ngAcceptInputType_igxGridForOfVariableSizes: unknown;
}

/**
 * Determines the Icon Button type.
 */
type IgxIconButtonType = typeof IgxBaseButtonType[keyof typeof IgxBaseButtonType];
/**
 * The IgxIconButtonDirective provides a way to use an icon as a fully functional button.
 *
 * @example
 * ```html
 * <button type="button" igxIconButton="outlined">
 *      <igx-icon>home</igx-icon>
 * </button>
 * ```
 */
declare class IgxIconButtonDirective extends IgxButtonBaseDirective {
    private static ngAcceptInputType_type;
    constructor();
    /**
     * @hidden
     * @internal
     */
    protected _cssClass: string;
    /**
     * @hidden
     * @internal
     */
    private _type;
    /**
     * Sets the type of the icon button.
     *
     * @example
     * ```html
     * <button type="button" igxIconButton="flat"></button>
     * ```
     */
    set type(type: IgxIconButtonType);
    /**
     * @hidden
     * @internal
     */
    get flat(): boolean;
    /**
     * @hidden
     * @internal
     */
    get contained(): boolean;
    /**
     * @hidden
     * @internal
     */
    get outlined(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxIconButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxIconButtonDirective, "[igxIconButton]", never, { "type": { "alias": "igxIconButton"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxLayoutDirective {
    /**
     * Sets the default flow direction of the container's children.
     *
     * Defaults to `rows`.
     *
     * ```html
     *  <div
     *   igxLayout
     *   igxLayoutDir="row">
     *    <div igxFlex>1</div>
     *    <div igxFlex>2</div>
     *    <div igxFlex>3</div>
     *  </div>
     * ```
     */
    dir: string;
    /**
     * Defines the direction flex children are placed in the flex container.
     *
     * When set to `true`, the `rows` direction goes right to left and `columns` goes bottom to top.
     *
     * ```html
     * <div
     *   igxLayout
     *   igxLayoutReverse="true">
     *    <div igxFlex>1</div>
     *    <div igxFlex>2</div>
     *    <div igxFlex>3</div>
     * </div>
     * ```
     */
    reverse: boolean;
    /**
     * By default the immediate children will all try to fit onto one line.
     *
     * The default value `nowrap` sets this behavior.
     *
     * Other accepted values are `wrap` and `wrap-reverse`.
     *
     * ```html
     * <div
     *   igxLayout
     *   igxLayoutDir="row"
     *   igxLayoutWrap="wrap">
     *    <div igxFlex igxFlexGrow="0">1</div>
     *    <div igxFlex igxFlexGrow="0">2</div>
     *    <div igxFlex igxFlexGrow="0">3</div>
     * </div>
     * ```
     */
    wrap: string;
    /**
     * Defines the alignment along the main axis.
     *
     * Defaults to `flex-start` which packs the children toward the start line.
     *
     * Other possible values are `flex-end`, `center`, `space-between`, `space-around`.
     *
     * ```html
     * <div
     *   igxLayout
     *   igxLayoutDir="column"
     *   igxLayoutJustify="space-between">
     *    <div>1</div>
     *    <div>2</div>
     *    <div>3</div>
     * </div>
     * ```
     */
    justify: string;
    /**
     * Defines the default behavior for how children are laid out along the corss axis of the current line.
     *
     * Defaults to `flex-start`.
     *
     * Other possible values are `flex-end`, `center`, `baseline`, and `stretch`.
     *
     * ```html
     * <div
     *   igxLayout
     *   igxLayoutDir="column"
     *   igxLayoutItemAlign="start">
     *    <div igxFlex igxFlexGrow="0">1</div>
     *    <div igxFlex igxFlexGrow="0">2</div>
     *    <div igxFlex igxFlexGrow="0">3</div>
     * </div>
     * ```
     */
    itemAlign: string;
    /**
     * @hidden
     */
    display: string;
    /**
     * @hidden
     */
    get flexwrap(): string;
    /**
     * @hidden
     */
    get justifycontent(): string;
    /**
     * @hidden
     */
    get align(): string;
    /**
     * @hidden
     */
    get direction(): "row" | "row-reverse" | "column-reverse" | "column";
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxLayoutDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxLayoutDirective, "[igxLayout]", never, { "dir": { "alias": "igxLayoutDir"; "required": false; }; "reverse": { "alias": "igxLayoutReverse"; "required": false; }; "wrap": { "alias": "igxLayoutWrap"; "required": false; }; "justify": { "alias": "igxLayoutJustify"; "required": false; }; "itemAlign": { "alias": "igxLayoutItemAlign"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_reverse: unknown;
}
declare class IgxFlexDirective {
    /**
     * Applies the `grow` attribute to an element that uses the directive.
     *
     * Default value is `1`.
     *
     * ```html
     * <div>
     *    <div igxFlex igxFlexGrow="0">Content1</div>
     *    <div igxFlex igxFlexGrow="1">Content2</div>
     *    <div igxFlex igxFlexGrow="0">Content3</div>
     * </div>
     * ```
     */
    grow: number;
    /**
     * Applies the `shrink` attribute to an element that uses the directive.
     *
     * Default value is `1`.
     *
     * ```html
     * <div>
     *    <div igxFlex igxFlexShrink="1">Content1</div>
     *    <div igxFlex igxFlexShrink="0">Content2</div>
     *    <div igxFlex igxFlexShrink="1">Content3</div>
     * </div>
     * ```
     */
    shrink: number;
    /**
     * Applies the directive to an element.
     *
     * Possible values include `igxFlexGrow`, `igxFlexShrink`, `igxFlexOrder`, `igxFlexBasis`.
     *
     * ```html
     * <div igxFlex>Content</div>
     * ```
     */
    flex: string;
    /**
     * Applies the `order` attribute to an element that uses the directive.
     *
     * Default value is `0`.
     *
     * ```html
     * <div>
     *    <div igxFlex igxFlexOrder="1">Content1</div>
     *    <div igxFlex igxFlexOrder="0">Content2</div>
     *    <div igxFlex igxFlexOrder="2">Content3</div>
     * </div>
     * ```
     */
    order: number;
    /**
     * Applies the `flex-basis` attribute to an element that uses the directive.
     *
     * Default value is `auto`.
     *
     * Other possible values include `content`, `max-content`, `min-content`, `fit-content`.
     *
     * ```html
     * <div igxFlex igxFlexBasis="fit-content">Content</div>
     * ```
     */
    basis: string;
    /**
     * @hidden
     */
    get style(): string;
    /**
     * @hidden
     */
    get itemorder(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFlexDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxFlexDirective, "[igxFlex]", never, { "grow": { "alias": "igxFlexGrow"; "required": false; }; "shrink": { "alias": "igxFlexShrink"; "required": false; }; "flex": { "alias": "igxFlex"; "required": false; }; "order": { "alias": "igxFlexOrder"; "required": false; }; "basis": { "alias": "igxFlexBasis"; "required": false; }; }, {}, never, never, true, never>;
}

/** @hidden */
interface MaskOptions {
    format: string;
    promptChar: string;
}
/** @hidden */
interface Replaced {
    value: string;
    end: number;
}
/** @hidden */
declare class MaskParsingService {
    applyMask(inputVal: string, maskOptions: MaskOptions, pos?: number): string;
    parseValueFromMask(maskedValue: string, maskOptions: MaskOptions): string;
    replaceInMask(maskedValue: string, value: string, maskOptions: MaskOptions, start: number, end: number): Replaced;
    /** Validates only non literal positions. */
    private validateCharOnPosition;
    private getNonLiteralIndices;
    private getNonLiteralValues;
    private replaceIMENumbers;
    static ɵfac: i0.ɵɵFactoryDeclaration<MaskParsingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MaskParsingService>;
}

declare class IgxMaskDirective implements OnInit, AfterViewChecked, ControlValueAccessor {
    protected elementRef: ElementRef<HTMLInputElement>;
    protected maskParser: MaskParsingService;
    protected renderer: Renderer2;
    protected platform: PlatformUtil;
    /**
     * Sets the input mask.
     * ```html
     * <input [igxMask] = "'00/00/0000'">
     * ```
     */
    get mask(): string;
    set mask(val: string);
    /**
     * Sets the character representing a fillable spot in the input mask.
     * Default value is "'_'".
     * ```html
     * <input [promptChar] = "'/'">
     * ```
     */
    promptChar: string;
    /**
     * Specifies if the bound value includes the formatting symbols.
     * ```html
     * <input [includeLiterals] = "true">
     * ```
     */
    includeLiterals: boolean;
    /**
     * Specifies a pipe to be used on blur.
     * ```html
     * <input [displayValuePipe] = "displayFormatPipe">
     * ```
     */
    displayValuePipe: PipeTransform;
    /**
     * Specifies a pipe to be used on focus.
     * ```html
     * <input [focusedValuePipe] = "inputFormatPipe">
     * ```
     */
    focusedValuePipe: PipeTransform;
    /**
     * Emits an event each time the value changes.
     * Provides `rawValue: string` and `formattedValue: string` as event arguments.
     * ```html
     * <input (valueChanged) = "valueChanged(rawValue: string, formattedValue: string)">
     * ```
     */
    valueChanged: EventEmitter<IMaskEventArgs>;
    /** @hidden */
    get nativeElement(): HTMLInputElement;
    /** @hidden @internal; */
    protected get inputValue(): string;
    /** @hidden @internal */
    protected set inputValue(val: string);
    /** @hidden */
    protected get maskOptions(): MaskOptions;
    /** @hidden */
    protected get selectionStart(): number;
    /** @hidden */
    protected get selectionEnd(): number;
    /** @hidden */
    protected get start(): number;
    /** @hidden */
    protected get end(): number;
    protected _composing: boolean;
    protected _compositionStartIndex: number;
    protected _focused: boolean;
    private _compositionValue;
    private _end;
    private _start;
    private _key;
    private _mask;
    private _oldText;
    private _dataValue;
    private _droppedData;
    private _hasDropAction;
    private readonly defaultMask;
    protected _onTouchedCallback: () => void;
    protected _onChangeCallback: (_: any) => void;
    /** @hidden */
    onKeyDown(event: KeyboardEvent): void;
    /** @hidden @internal */
    onCompositionStart(): void;
    /** @hidden @internal */
    onCompositionEnd(): void;
    /** @hidden @internal */
    onInputChanged(event: any): void;
    /** @hidden */
    onPaste(): void;
    /** @hidden */
    onFocus(): void;
    /** @hidden */
    onBlur(event: FocusEvent): void;
    /** @hidden */
    onDragEnter(): void;
    /** @hidden */
    onDragLeave(): void;
    /** @hidden */
    onDrop(event: DragEvent): void;
    /** @hidden */
    ngOnInit(): void;
    /**
     * TODO: Remove after date/time picker integration refactor
     *
     * @hidden
     */
    ngAfterViewChecked(): void;
    /** @hidden */
    writeValue(value: string): void;
    /** @hidden */
    registerOnChange(fn: (_: any) => void): void;
    /** @hidden */
    registerOnTouched(fn: () => void): void;
    /** @hidden */
    protected showMask(value: string): void;
    /** @hidden */
    protected setSelectionRange(start: number, end?: number): void;
    /** @hidden */
    protected afterInput(): void;
    /** @hidden */
    protected setPlaceholder(value: string): void;
    private updateInputValue;
    private updateInput;
    private showDisplayValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxMaskDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxMaskDirective, "[igxMask]", ["igxMask"], { "mask": { "alias": "igxMask"; "required": false; }; "promptChar": { "alias": "promptChar"; "required": false; }; "includeLiterals": { "alias": "includeLiterals"; "required": false; }; "displayValuePipe": { "alias": "displayValuePipe"; "required": false; }; "focusedValuePipe": { "alias": "focusedValuePipe"; "required": false; }; }, { "valueChanged": "valueChanged"; }, never, never, true, never>;
    static ngAcceptInputType_includeLiterals: unknown;
}
/**
 * The IgxMaskModule provides the {@link IgxMaskDirective} inside your application.
 */
interface IMaskEventArgs extends IBaseEventArgs {
    rawValue: string;
    formattedValue: string;
}

declare class IgxRippleDirective {
    protected builder: AnimationBuilder;
    protected elementRef: ElementRef<any>;
    protected renderer: Renderer2;
    private zone;
    /**
     * Sets/gets the ripple target.
     * ```html
     * <div  #rippleContainer class="div-1" igxRipple [igxRippleTarget] = "'.div-1'"></div>
     * ```
     * ```typescript
     * @ViewChild('rippleContainer', {read: IgxRippleDirective})
     * public ripple: IgxRippleDirective;
     * let rippleTarget = this.ripple.rippleTarget;
     * ```
     * Can set the ripple to activate on a child element inside the parent where igxRipple is defined.
     * ```html
     * <div #rippleContainer [igxRippleTarget]="'#child"'>
     *   <button type="button" igxButton id="child">Click</button>
     * </div>
     * ```
     *
     * @memberof IgxRippleDirective
     */
    rippleTarget: string;
    /**
     * Sets/gets the ripple color.
     * ```html
     * <button type="button" #rippleContainer igxButton [igxRipple]="'red'"></button>
     * ```
     * ```typescript
     * @ViewChild('rippleContainer', {read: IgxRippleDirective})
     * public ripple: IgxRippleDirective;
     * let rippleColor = this.ripple.rippleColor;
     * ```
     *
     * @memberof IgxRippleDirective
     */
    rippleColor: string;
    /**
     * Sets/gets the ripple duration(in milliseconds).
     * Default value is `600`.
     * ```html
     * <button type="button" #rippleContainer igxButton igxRipple [igxRippleDuration]="800"></button>
     * ```
     * ```typescript
     * @ViewChild('rippleContainer', {read: IgxRippleDirective})
     * public ripple: IgxRippleDirective;
     * let rippleDuration = this.ripple.rippleDuration;
     * ```
     *
     * @memberof IgxRippleDirective
     */
    rippleDuration: number;
    /**
     * Enables/disables the ripple to be centered.
     * ```html
     * <button type="button" #rippleContainer igxButton igxRipple [igxRippleCentered]="true"></button>
     * ```
     *
     * @memberof IgxRippleDirective
     */
    set centered(value: boolean);
    /**
     * Sets/gets whether the ripple is disabled.
     * Default value is `false`.
     * ```html
     * <button type="button" #rippleContainer igxRipple [igxRippleDisabled]="true"></button>
     * ```
     * ```typescript
     * @ViewChild('rippleContainer', {read: IgxRippleDirective})
     * public ripple: IgxRippleDirective;
     * let isRippleDisabled = this.ripple.rippleDisabled;
     * ```
     *
     * @memberof IgxRippleDirective
     */
    rippleDisabled: boolean;
    protected get nativeElement(): HTMLElement;
    private rippleElementClass;
    private rippleHostClass;
    private _centered;
    private animationQueue;
    /**
     * @hidden
     */
    onMouseDown(event: any): void;
    private setStyles;
    private _ripple;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRippleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxRippleDirective, "[igxRipple]", never, { "rippleTarget": { "alias": "igxRippleTarget"; "required": false; }; "rippleColor": { "alias": "igxRipple"; "required": false; }; "rippleDuration": { "alias": "igxRippleDuration"; "required": false; }; "centered": { "alias": "igxRippleCentered"; "required": false; }; "rippleDisabled": { "alias": "igxRippleDisabled"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_centered: unknown;
    static ngAcceptInputType_rippleDisabled: unknown;
}

declare class IgSizeDirective {
    private _size;
    get igSize(): string;
    set igSize(value: 'small' | 'medium' | 'large');
    static ɵfac: i0.ɵɵFactoryDeclaration<IgSizeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgSizeDirective, "[igSize]", never, { "igSize": { "alias": "igSize"; "required": false; }; }, {}, never, never, true, never>;
}

interface IBaseSearchInfo {
    searchText: string;
    caseSensitive: boolean;
    exactMatch: boolean;
    matchCount: number;
    content: string;
}
/**
 * An interface describing information for the active highlight.
 */
interface IActiveHighlightInfo {
    /**
     * The row of the highlight.
     */
    row?: any;
    /**
     * The column of the highlight.
     */
    column?: any;
    /**
     * The index of the highlight.
     */
    index: number;
    /**
     * Additional, custom checks to perform prior an element highlighting.
     */
    metadata?: Map<string, any>;
}
declare class IgxTextHighlightDirective implements AfterViewInit, AfterViewChecked, OnDestroy, OnChanges {
    private element;
    private service;
    private renderer;
    /**
     * Determines the `CSS` class of the highlight elements.
     * This allows the developer to provide custom `CSS` to customize the highlight.
     *
     * ```html
     * <div
     *   igxTextHighlight
     *   [cssClass]="myClass">
     * </div>
     * ```
     */
    cssClass: string;
    /**
     * Determines the `CSS` class of the active highlight element.
     * This allows the developer to provide custom `CSS` to customize the highlight.
     *
     * ```html
     * <div
     *   igxTextHighlight
     *   [activeCssClass]="activeHighlightClass">
     * </div>
     * ```
     */
    activeCssClass: string;
    /**
     * @hidden
     */
    containerClass: string;
    /**
     * Identifies the highlight within a unique group.
     * This allows it to have several different highlight groups,
     * with each of them having their own active highlight.
     *
     * ```html
     * <div
     *   igxTextHighlight
     *   [groupName]="myGroupName">
     * </div>
     * ```
     */
    groupName: string;
    /**
     * The underlying value of the element that will be highlighted.
     *
     * ```typescript
     * // get
     * const elementValue = this.textHighlight.value;
     * ```
     *
     * ```html
     * <!--set-->
     * <div
     *   igxTextHighlight
     *   [value]="newValue">
     * </div>
     * ```
     */
    get value(): any;
    set value(value: any);
    /**
     * The identifier of the row on which the directive is currently on.
     *
     * ```html
     * <div
     *   igxTextHighlight
     *   [row]="0">
     * </div>
     * ```
     */
    row: any;
    /**
     * The identifier of the column on which the directive is currently on.
     *
     * ```html
     * <div
     *   igxTextHighlight
     *   [column]="0">
     * </div>
     * ```
     */
    column: any;
    /**
     * A map that contains all additional conditions, that you need to activate a highlighted
     * element. To activate the condition, you will have to add a new metadata key to
     * the `metadata` property of the IActiveHighlightInfo interface.
     *
     * @example
     * ```typescript
     *  // Set a property, which would disable the highlight for a given element on a certain condition
     *  const metadata = new Map<string, any>();
     *  metadata.set('highlightElement', false);
     * ```
     * ```html
     * <div
     *   igxTextHighlight
     *   [metadata]="metadata">
     * </div>
     * ```
     */
    metadata: Map<string, any>;
    /**
     * @hidden
     */
    get lastSearchInfo(): IBaseSearchInfo;
    /**
     * @hidden
     */
    parentElement: any;
    private _container;
    private destroy$;
    private _value;
    private _lastSearchInfo;
    private _div;
    private _observer;
    private _nodeWasRemoved;
    private _forceEvaluation;
    private _activeElementIndex;
    private _valueChanged;
    private _defaultCssClass;
    private _defaultActiveCssClass;
    constructor();
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * @hidden
     */
    ngOnChanges(changes: SimpleChanges): void;
    /**
     * @hidden
     */
    ngAfterViewInit(): void;
    /**
     * @hidden
     */
    ngAfterViewChecked(): void;
    /**
     * Clears the existing highlight and highlights the searched text.
     * Returns how many times the element contains the searched text.
     */
    highlight(text: string, caseSensitive?: boolean, exactMatch?: boolean): number;
    /**
     * Clears any existing highlight.
     */
    clearHighlight(): void;
    /**
     * Activates the highlight if it is on the currently active row and column.
     */
    activateIfNecessary(): void;
    /**
     * Attaches a MutationObserver to the parentElement and watches for when the container element is removed/readded to the DOM.
     * Should be used only when necessary as using many observers may lead to performance degradation.
     */
    observe(): void;
    private activate;
    private deactivate;
    private clearChildElements;
    private getHighlightedText;
    private appendText;
    private appendSpan;
    private appendDiv;
    private searchNeedsEvaluation;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTextHighlightDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxTextHighlightDirective, "[igxTextHighlight]", never, { "cssClass": { "alias": "cssClass"; "required": false; }; "activeCssClass": { "alias": "activeCssClass"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; "groupName": { "alias": "groupName"; "required": false; }; "value": { "alias": "value"; "required": false; }; "row": { "alias": "row"; "required": false; }; "column": { "alias": "column"; "required": false; }; "metadata": { "alias": "metadata"; "required": false; }; }, {}, never, never, true, never>;
}

declare class IgxTextSelectionDirective {
    private element;
    /**
     *  Determines whether the input element could be selected through the directive.
     *
     * ```html
     * <!--set-->
     * <input
     *   type="text"
     *   id="firstName"
     *   [igxTextSelection]="true">
     * </input>
     *
     * <input
     *   type="text"
     *   id="lastName"
     *   igxTextSelection
     *   [selected]="true">
     * </input>
     * ```
     */
    selected: boolean;
    /**
     * Returns the nativeElement of the element where the directive was applied.
     *
     * ```html
     * <input
     *   type="text"
     *   id="firstName"
     *   igxTextSelection>
     * </input>
     * ```
     *
     * ```typescript
     * @ViewChild('firstName',
     *  {read: IgxTextSelectionDirective})
     * public inputElement: IgxTextSelectionDirective;
     *
     * public getNativeElement() {
     *  return this.inputElement.nativeElement;
     * }
     * ```
     */
    get nativeElement(): any;
    /**
     * @hidden
     */
    onFocus(): void;
    /**
     * Triggers the selection of the element if it is marked as selectable.
     *
     * ```html
     * <input
     *   type="text"
     *   id="firstName"
     *   igxTextSelection>
     * </input>
     * ```
     *
     * ```typescript
     * @ViewChild('firstName',
     *  {read: IgxTextSelectionDirective})
     * public inputElement: IgxTextSelectionDirective;
     *
     * public triggerElementSelection() {
     *  this.inputElement.trigger();
     * }
     * ```
     */
    trigger(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTextSelectionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxTextSelectionDirective, "[igxTextSelection]", ["igxTextSelection"], { "selected": { "alias": "igxTextSelection"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_selected: unknown;
}

/**
 * @hidden
 */
declare class IgxTemplateOutletDirective implements OnChanges {
    _viewContainerRef: ViewContainerRef;
    private _zone;
    cdr: ChangeDetectorRef;
    igxTemplateOutletContext: any;
    igxTemplateOutlet: TemplateRef<any>;
    viewCreated: EventEmitter<IViewChangeEventArgs>;
    viewMoved: EventEmitter<IViewChangeEventArgs>;
    cachedViewLoaded: EventEmitter<ICachedViewLoadedEventArgs>;
    beforeViewDetach: EventEmitter<IViewChangeEventArgs>;
    private _viewRef;
    /**
     * The embedded views cache. Collection is key-value paired.
     * Key is the template type, value is another key-value paired collection
     * where the key is the template id and value is the embedded view for the related template.
     */
    private _embeddedViewsMap;
    ngOnChanges(changes: SimpleChanges): void;
    cleanCache(): void;
    cleanView(tmplID: any): void;
    private _recreateView;
    private _moveView;
    private _useCachedView;
    private _shouldRecreateView;
    private _hasContextShapeChanged;
    private _updateExistingContext;
    private _cloneContext;
    private _getActionType;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTemplateOutletDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxTemplateOutletDirective, "[igxTemplateOutlet]", never, { "igxTemplateOutletContext": { "alias": "igxTemplateOutletContext"; "required": false; }; "igxTemplateOutlet": { "alias": "igxTemplateOutlet"; "required": false; }; }, { "viewCreated": "viewCreated"; "viewMoved": "viewMoved"; "cachedViewLoaded": "cachedViewLoaded"; "beforeViewDetach": "beforeViewDetach"; }, never, never, true, never>;
}
interface IViewChangeEventArgs extends IBaseEventArgs {
    owner: IgxTemplateOutletDirective;
    view: EmbeddedViewRef<any>;
    context: any;
}
interface ICachedViewLoadedEventArgs extends IViewChangeEventArgs {
    oldContext: any;
}

interface ToggleViewEventArgs extends IBaseEventArgs {
    /** Id of the toggle view */
    id: string;
    /** Provides reference to the owner component (from IBaseEventArgs) */
    owner?: any;
    event?: Event;
}
interface ToggleViewCancelableEventArgs extends ToggleViewEventArgs, CancelableBrowserEventArgs {
    cancel: boolean;
}
declare class IgxToggleDirective implements IToggleView, OnInit, OnDestroy {
    private elementRef;
    private cdr;
    protected overlayService: IgxOverlayService;
    private navigationService;
    private platform;
    /**
     * Emits an event after the toggle container is opened.
     *
     * ```typescript
     * onToggleOpened(event) {
     *    alert("Toggle opened!");
     * }
     * ```
     *
     * ```html
     * <div
     *   igxToggle
     *   (opened)='onToggleOpened($event)'>
     * </div>
     * ```
     */
    opened: EventEmitter<ToggleViewEventArgs>;
    /**
     * Emits an event before the toggle container is opened.
     *
     * ```typescript
     * onToggleOpening(event) {
     *  alert("Toggle opening!");
     * }
     * ```
     *
     * ```html
     * <div
     *   igxToggle
     *   (opening)='onToggleOpening($event)'>
     * </div>
     * ```
     */
    opening: EventEmitter<ToggleViewCancelableEventArgs>;
    /**
     * Emits an event after the toggle container is closed.
     *
     * ```typescript
     * onToggleClosed(event) {
     *  alert("Toggle closed!");
     * }
     * ```
     *
     * ```html
     * <div
     *   igxToggle
     *   (closed)='onToggleClosed($event)'>
     * </div>
     * ```
     */
    closed: EventEmitter<ToggleViewEventArgs>;
    /**
     * Emits an event before the toggle container is closed.
     *
     * ```typescript
     * onToggleClosing(event) {
     *  alert("Toggle closing!");
     * }
     * ```
     *
     * ```html
     * <div
     *  igxToggle
     *  (closing)='onToggleClosing($event)'>
     * </div>
     * ```
     */
    closing: EventEmitter<ToggleViewCancelableEventArgs>;
    /**
     * Emits an event after the toggle element is appended to the overlay container.
     *
     * ```typescript
     * onAppended() {
     *  alert("Content appended!");
     * }
     * ```
     *
     * ```html
     * <div
     *   igxToggle
     *   (appended)='onToggleAppended()'>
     * </div>
     * ```
     */
    appended: EventEmitter<ToggleViewEventArgs>;
    /**
     * @hidden
     */
    get collapsed(): boolean;
    /**
     * Identifier which is registered into `IgxNavigationService`
     *
     * ```typescript
     * let myToggleId = this.toggle.id;
     * ```
     */
    id: string;
    /**
     * @hidden
     */
    get element(): HTMLElement;
    /**
     * @hidden
     */
    get hiddenClass(): boolean;
    /**
     * @hidden
     */
    get hiddenWebkitClass(): boolean;
    /**
     * @hidden
     */
    get defaultClass(): boolean;
    protected _overlayId: string;
    private _collapsed;
    protected destroy$: Subject<boolean>;
    private _overlaySubFilter;
    private _overlayOpenedSub;
    private _overlayClosingSub;
    private _overlayClosedSub;
    private _overlayContentAppendedSub;
    /**
     * Opens the toggle.
     *
     * ```typescript
     * this.myToggle.open();
     * ```
     */
    open(overlaySettings?: OverlaySettings): void;
    /**
     * Closes the toggle.
     *
     * ```typescript
     * this.myToggle.close();
     * ```
     */
    close(event?: Event): void;
    /**
     * Opens or closes the toggle, depending on its current state.
     *
     * ```typescript
     * this.myToggle.toggle();
     * ```
     */
    toggle(overlaySettings?: OverlaySettings): void;
    /** @hidden @internal */
    get isClosing(): boolean;
    /**
     * Returns the id of the overlay the content is rendered in.
     * ```typescript
     * this.myToggle.overlayId;
     * ```
     */
    get overlayId(): string;
    /**
     * Repositions the toggle.
     * ```typescript
     * this.myToggle.reposition();
     * ```
     */
    reposition(): void;
    /**
     * Offsets the content along the corresponding axis by the provided amount with optional
     * offsetMode that determines whether to add (by default) or set the offset values with OffsetMode.Add and OffsetMode.Set
     */
    setOffset(deltaX: number, deltaY: number, offsetMode?: OffsetMode): void;
    /**
     * @hidden
     */
    ngOnInit(): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    private overlayClosed;
    private subscribe;
    private unsubscribe;
    private clearSubscription;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxToggleDirective, "[igxToggle]", ["toggle"], { "id": { "alias": "id"; "required": false; }; }, { "opened": "opened"; "opening": "opening"; "closed": "closed"; "closing": "closing"; "appended": "appended"; }, never, never, true, never>;
}
declare class IgxToggleActionDirective implements OnInit {
    protected element: ElementRef<any>;
    protected navigationService: IgxNavigationService;
    /**
     * Provide settings that control the toggle overlay positioning, interaction and scroll behavior.
     * ```typescript
     * const settings: OverlaySettings = {
     *      closeOnOutsideClick: false,
     *      modal: false
     *  }
     * ```
     * ---
     * ```html
     * <!--set-->
     * <div igxToggleAction [overlaySettings]="settings"></div>
     * ```
     */
    overlaySettings: OverlaySettings;
    /**
     * Determines where the toggle element overlay should be attached.
     *
     * ```html
     * <!--set-->
     * <div igxToggleAction [igxToggleOutlet]="outlet"></div>
     * ```
     * Where `outlet` in an instance of `IgxOverlayOutletDirective` or an `ElementRef`
     */
    outlet: IgxOverlayOutletDirective | ElementRef;
    /**
     * @hidden
     */
    set target(target: any);
    /**
     * @hidden
     */
    get target(): any;
    protected _overlayDefaults: OverlaySettings;
    protected _target: IToggleView | string;
    /**
     * @hidden
     */
    onClick(): void;
    /**
     * @hidden
     */
    ngOnInit(): void;
    /**
     * Updates provided overlay settings
     *
     * @param settings settings to update
     * @returns returns updated copy of provided overlay settings
     */
    protected updateOverlaySettings(settings: OverlaySettings): OverlaySettings;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxToggleActionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxToggleActionDirective, "[igxToggleAction]", ["toggle-action"], { "overlaySettings": { "alias": "overlaySettings"; "required": false; }; "outlet": { "alias": "igxToggleOutlet"; "required": false; }; "target": { "alias": "igxToggleAction"; "required": false; }; }, {}, never, never, true, never>;
}

/**
 * **Ignite UI for Angular Tooltip** -
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/tooltip)
 *
 * The Ignite UI for Angular Tooltip directive is used to mark an HTML element in the markup as one that should behave as a tooltip.
 * The tooltip is used in combination with the Ignite UI for Angular Tooltip Target by assigning the exported tooltip reference to the
 * respective target's selector property.
 *
 * Example:
 * ```html
 * <button type="button" igxButton [igxTooltipTarget]="tooltipRef">Hover me</button>
 * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
 * ```
 */
declare class IgxTooltipDirective extends IgxToggleDirective implements AfterViewInit, OnDestroy {
    /**
     * @hidden
     */
    get hiddenClass(): boolean;
    /**
     * @hidden
     */
    get defaultClass(): boolean;
    /**
     * Gets/sets any tooltip related data.
     * The 'context' can be used for storing any information that is necessary
     * to access when working with the tooltip.
     *
     * ```typescript
     * // get
     * let tooltipContext = this.tooltip.context;
     * ```
     *
     * ```typescript
     * // set
     * this.tooltip.context = "Tooltip's context";
     * ```
     */
    context: any;
    /**
     * Identifier for the tooltip.
     * If this is property is not explicitly set, it will be automatically generated.
     *
     * ```typescript
     * let tooltipId = this.tooltip.id;
     * ```
     */
    id: string;
    /**
     * Get the role attribute of the tooltip.
     *
     * ```typescript
     * let tooltipRole = this.tooltip.role;
     * ```
     */
    set role(value: "tooltip" | "status");
    get role(): "tooltip" | "status";
    /**
     * Get the arrow element of the tooltip.
     *
     * ```typescript
     * let tooltipArrow = this.tooltip.arrow;
     * ```
     */
    get arrow(): HTMLElement;
    /**
     * @hidden
     */
    timeoutId: any;
    /**
     * @hidden
     */
    tooltipTarget: IgxTooltipTargetDirective;
    private _arrowEl;
    private _role;
    private _destroy$;
    private _document;
    private _renderer;
    private _platformUtil;
    /** @hidden */
    constructor();
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * @hidden
     */
    onMouseEnter(): void;
    /**
     * @hidden
     */
    onMouseLeave(): void;
    /**
     * If there is an animation in progress, this method will reset it to its initial state.
     * Allows hovering over the tooltip while an open/close animation is running.
     * Stops the animation and immediately shows the tooltip.
     *
     * @hidden
     */
    stopAnimations(): void;
    /**
     * If there is a close animation in progress, this method will end it.
     * If there is no close animation in progress, this method will close the tooltip with no animation.
     *
     * @param overlaySettings settings to use for closing the tooltip
     * @hidden
     */
    forceClose(overlaySettings: OverlaySettings): void;
    private _createArrow;
    private _removeArrow;
    private onDocumentTouchStart;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxTooltipDirective, "[igxTooltip]", ["tooltip"], { "context": { "alias": "context"; "required": false; }; "id": { "alias": "id"; "required": false; }; "role": { "alias": "role"; "required": false; }; }, {}, never, never, true, never>;
}

interface ITooltipShowEventArgs extends IBaseEventArgs {
    target: IgxTooltipTargetDirective;
    tooltip: IgxTooltipDirective;
    cancel: boolean;
}
interface ITooltipHideEventArgs extends IBaseEventArgs {
    target: IgxTooltipTargetDirective;
    tooltip: IgxTooltipDirective;
    cancel: boolean;
}
/**
 * **Ignite UI for Angular Tooltip Target** -
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/tooltip)
 *
 * The Ignite UI for Angular Tooltip Target directive is used to mark an HTML element in the markup as one that has a tooltip.
 * The tooltip target is used in combination with the Ignite UI for Angular Tooltip by assigning the exported tooltip reference to the
 * target's selector property.
 *
 * Example:
 * ```html
 * <button type="button" igxButton [igxTooltipTarget]="tooltipRef">Hover me</button>
 * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
 * ```
 */
declare class IgxTooltipTargetDirective extends IgxToggleActionDirective implements OnInit, AfterViewInit, OnDestroy {
    private _viewContainerRef;
    private _renderer;
    private _envInjector;
    /**
     * Gets/sets the amount of milliseconds that should pass before showing the tooltip.
     *
     * ```typescript
     * // get
     * let tooltipShowDelay = this.tooltipTarget.showDelay;
     * ```
     *
     * ```html
     * <!--set-->
     * <button type="button" igxButton [igxTooltipTarget]="tooltipRef" [showDelay]="1500">Hover me</button>
     * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
     * ```
     */
    showDelay: number;
    /**
     * Gets/sets the amount of milliseconds that should pass before hiding the tooltip.
     *
     * ```typescript
     * // get
     * let tooltipHideDelay = this.tooltipTarget.hideDelay;
     * ```
     *
     * ```html
     * <!--set-->
     * <button type="button" igxButton [igxTooltipTarget]="tooltipRef" [hideDelay]="1500">Hover me</button>
     * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
     * ```
     */
    hideDelay: number;
    /**
     * Controls whether to display an arrow indicator for the tooltip.
     * Set to true to show the arrow. Default value is `false`.
     *
     * ```typescript
     * // get
     * let isArrowDisabled = this.tooltip.hasArrow;
     * ```
     *
     * ```typescript
     * // set
     * this.tooltip.hasArrow = true;
     * ```
     *
     * ```html
     * <!--set-->
     * <igx-icon igxTooltipTarget [hasArrow]="true" [tooltip]="'Infragistics Inc. HQ'">info</igx-icon>
     * ```
     */
    set hasArrow(value: boolean);
    get hasArrow(): boolean;
    /**
     * Specifies if the tooltip remains visible until the user closes it via the close button or Esc key.
     *
     * ```typescript
     * // get
     * let isSticky = this.tooltip.sticky;
     * ```
     *
     * ```typescript
     * // set
     * this.tooltip.sticky = true;
     * ```
     *
     * ```html
     * <!--set-->
     * <igx-icon igxTooltipTarget [sticky]="true" [tooltip]="'Infragistics Inc. HQ'">info</igx-icon>
     * ```
     */
    set sticky(value: boolean);
    get sticky(): boolean;
    /**
     *  Allows full control over the appearance of the close button inside the tooltip.
     *
     * ```typescript
     * // get
     * let customCloseTemplate = this.tooltip.customCloseTemplate;
     * ```
     *
     * ```typescript
     * // set
     * this.tooltip.customCloseTemplate = TemplateRef<any>;
     * ```
     *
     * ```html
     * <!--set-->
     * <igx-icon igxTooltipTarget [closeButtonTemplate]="customClose" [tooltip]="'Infragistics Inc. HQ'">info</igx-icon>
     * <ng-template #customClose>
     *      <button class="my-close-btn">Close Me</button>
     * </ng-template>
     * ```
     */
    set closeTemplate(value: TemplateRef<any>);
    get closeTemplate(): TemplateRef<any> | undefined;
    /**
     * Get the position and animation settings used by the tooltip.
     * ```typescript
     * let positionSettings = this.tooltipTarget.positionSettings;
     * ```
     */
    get positionSettings(): PositionSettings;
    /**
     * Set the position and animation settings used by the tooltip.
     * ```html
     * <igx-icon [igxTooltipTarget]="tooltipRef" [positionSettings]="newPositionSettings">info</igx-icon>
     * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
     * ```
     * ```typescript
     *
     * import { PositionSettings, HorizontalAlignment, VerticalAlignment } from 'igniteui-angular';
     * ...
     * public newPositionSettings: PositionSettings = {
     *     horizontalDirection: HorizontalAlignment.Right,
     *     horizontalStartPoint: HorizontalAlignment.Left,
     *     verticalDirection: VerticalAlignment.Top,
     *     verticalStartPoint: VerticalAlignment.Top,
     * };
     * ```
     */
    set positionSettings(settings: PositionSettings);
    /**
     * Specifies if the tooltip should not show when hovering its target with the mouse. (defaults to false)
     * While setting this property to 'true' will disable the user interactions that shows/hides the tooltip,
     * the developer will still be able to show/hide the tooltip through the API.
     *
     * ```typescript
     * // get
     * let tooltipDisabledValue = this.tooltipTarget.tooltipDisabled;
     * ```
     *
     * ```html
     * <!--set-->
     * <button type="button" igxButton [igxTooltipTarget]="tooltipRef" [tooltipDisabled]="true">Hover me</button>
     * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
     * ```
     */
    tooltipDisabled: boolean;
    /**
     * @hidden
     */
    set target(target: any);
    /**
     * @hidden
     */
    get target(): any;
    /**
    * @hidden
    */
    set tooltip(content: any);
    /**
     * Gets the respective native element of the directive.
     *
     * ```typescript
     * let tooltipTargetElement = this.tooltipTarget.nativeElement;
     * ```
     */
    get nativeElement(): any;
    /**
     * Indicates if the tooltip that is is associated with this target is currently hidden.
     *
     * ```typescript
     * let tooltipHiddenValue = this.tooltipTarget.tooltipHidden;
     * ```
     */
    get tooltipHidden(): boolean;
    /**
     * Emits an event when the tooltip that is associated with this target starts showing.
     * This event is fired before the start of the countdown to showing the tooltip.
     *
     * ```typescript
     * tooltipShowing(args: ITooltipShowEventArgs) {
     *    alert("Tooltip started showing!");
     * }
     * ```
     *
     * ```html
     * <button type="button" igxButton [igxTooltipTarget]="tooltipRef" (tooltipShow)='tooltipShowing($event)'>Hover me</button>
     * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
     * ```
     */
    tooltipShow: EventEmitter<ITooltipShowEventArgs>;
    /**
     * Emits an event when the tooltip that is associated with this target starts hiding.
     * This event is fired before the start of the countdown to hiding the tooltip.
     *
     * ```typescript
     * tooltipHiding(args: ITooltipHideEventArgs) {
     *    alert("Tooltip started hiding!");
     * }
     * ```
     *
     * ```html
     * <button type="button" igxButton [igxTooltipTarget]="tooltipRef" (tooltipHide)='tooltipHiding($event)'>Hover me</button>
     * <span #tooltipRef="tooltip" igxTooltip>Hello there, I am a tooltip!</span>
     * ```
     */
    tooltipHide: EventEmitter<ITooltipHideEventArgs>;
    private _destroy$;
    private _autoHideDelay;
    private _isForceClosed;
    private _hasArrow;
    private _closeButtonRef?;
    private _closeTemplate;
    private _sticky;
    private _positionSettings;
    /**
     * @hidden
     */
    onClick(): void;
    /**
     * @hidden
     */
    onMouseEnter(): void;
    /**
     * @hidden
     */
    onMouseLeave(): void;
    /**
     * @hidden
     */
    onTouchStart(): void;
    /**
     * @hidden
     */
    onDocumentTouchStart(event: any): void;
    /**
     * @hidden
     */
    ngOnInit(): void;
    /**
     * @hidden
     */
    ngAfterViewInit(): void;
    /**
     * @hidden
     */
    ngOnDestroy(): void;
    /**
     * Shows the tooltip if not already shown.
     *
     * ```typescript
     * this.tooltipTarget.showTooltip();
     * ```
     */
    showTooltip(): void;
    /**
     * Hides the tooltip if not already hidden.
     *
     * ```typescript
     * this.tooltipTarget.hideTooltip();
     * ```
     */
    hideTooltip(): void;
    private get _mergedOverlaySettings();
    private _checkOutletAndOutsideClick;
    /**
     * A guard method that performs precondition checks before showing the tooltip.
     * It ensures that the tooltip is not disabled and not already shown in sticky mode.
     * If all conditions pass, it executes the provided `action` callback.
     */
    private _checksBeforeShowing;
    private _hideTooltip;
    private _showTooltip;
    private _showOnInteraction;
    private _hideOnInteraction;
    private _setAutoHide;
    /**
     * Used when the browser animations are set to a lower percentage
     * and the user interacts with the target or tooltip __while__ an animation is playing.
     * It stops the running animation, and the tooltip is instantly shown.
     */
    private _stopTimeoutAndAnimation;
    /**
     * Used when a single tooltip is used for multiple targets.
     */
    private _checkTooltipForMultipleTargets;
    /**
     * Updates the tooltip's sticky-related state, but only if the current target owns the tooltip.
     *
     * This method ensures that when the active target modifies its `sticky` or `closeTemplate` properties
     * at runtime, the tooltip reflects those changes accordingly:
     */
    private _evaluateStickyState;
    /**
     * Creates (if not already created) an instance of the IgxTooltipCloseButtonComponent,
     * and assigns it the provided custom template.
     */
    private _createCloseTemplate;
    /**
     * Appends the close button to the tooltip.
     */
    private _appendCloseButtonToTooltip;
    /**
     * Removes the close button from the tooltip.
     */
    private _removeCloseButtonFromTooltip;
    private _destroyCloseButton;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTooltipTargetDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxTooltipTargetDirective, "[igxTooltipTarget]", ["tooltipTarget"], { "showDelay": { "alias": "showDelay"; "required": false; }; "hideDelay": { "alias": "hideDelay"; "required": false; }; "hasArrow": { "alias": "hasArrow"; "required": false; }; "sticky": { "alias": "sticky"; "required": false; }; "closeTemplate": { "alias": "closeButtonTemplate"; "required": false; }; "positionSettings": { "alias": "positionSettings"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "target": { "alias": "igxTooltipTarget"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; }, { "tooltipShow": "tooltipShow"; "tooltipHide": "tooltipHide"; }, never, never, true, never>;
    static ngAcceptInputType_tooltipDisabled: unknown;
}

interface ArrowFit {
    /** Rectangle of the arrow element. */
    readonly arrowRect?: Partial<DOMRect>;
    /** Rectangle of the tooltip element. */
    readonly tooltipRect?: Partial<DOMRect>;
    /** Direction in which the arrow points. */
    readonly direction?: 'top' | 'bottom' | 'right' | 'left';
    /** Vertical offset of the arrow element from the tooltip */
    top?: number;
    /** Horizontal offset of the arrow element from the tooltip */
    left?: number;
}
declare class TooltipPositionStrategy extends AutoPositionStrategy {
    private _placement;
    constructor(settings?: PositionSettings);
    position(contentElement: HTMLElement, size: Size, document?: Document, initialCall?: boolean, target?: Point | HTMLElement): void;
    protected fitInViewport(element: HTMLElement, connectedFit: ConnectedFit): void;
    /**
     * Sets the position of the arrow relative to the tooltip element.
     *
     * @param arrow the arrow element of the tooltip.
     * @param arrowFit arrowFit object containing all necessary parameters.
     */
    positionArrow(arrow: HTMLElement, arrowFit: ArrowFit): void;
    /**
     * Resets the element's top / bottom / left / right style properties.
     *
     * @param arrow the arrow element of the tooltip.
     */
    private resetArrowPositionStyles;
    /**
     * Gets values for `top` or `left` position styles.
     *
     * @param arrowRect
     * @param tooltipRect
     * @param positionProperty - for which position property to get style values.
     */
    private getArrowPositionStyles;
    /**
     * Configure arrow class and arrowFit.
     *
     * @param tooltip tooltip element.
     */
    private configArrow;
    /**
     * Gets the placement that correspond to the given position settings.
     * Returns `undefined` if the position settings do not match any of the predefined placement values.
     *
     * @param settings Position settings for which to get the corresponding placement.
     */
    private getPlacementByPositionSettings;
    /**
    * Gets opposite direction, e.g., top -> bottom
    *
    * @param direction for which direction to return its opposite.
    * @returns `top` | `bottom` | `right` | `left`
    */
    private getOppositeDirection;
}

declare const IGX_TOOLTIP_DIRECTIVES: readonly [typeof IgxTooltipDirective, typeof IgxTooltipTargetDirective];

interface IgxDateTimeEditorEventArgs {
    readonly oldValue?: Date;
    newValue?: Date;
    readonly userInput: string;
}

/**
 * Date Time Editor provides a functionality to input, edit and format date and time.
 *
 * @igxModule IgxDateTimeEditorModule
 *
 * @igxParent IgxInputGroup
 *
 * @igxTheme igx-input-theme
 *
 * @igxKeywords date, time, editor
 *
 * @igxGroup Scheduling
 *
 * @remarks
 *
 * The Ignite UI Date Time Editor Directive makes it easy for developers to manipulate date/time user input.
 * It requires input in a specified or default input format which is visible in the input element as a placeholder.
 * It allows the input of only date (ex: 'dd/MM/yyyy'), only time (ex:'HH:mm tt') or both at once, if needed.
 * Supports display format that may differ from the input format.
 * Provides methods to increment and decrement any specific/targeted `DatePart`.
 *
 * **Note:** This directive uses the Mask Directive internally and requires `type="text"` on the input element.
 * Input elements with `type="date"` or other date/time types are not supported, as they do not allow
 * programmatic cursor positioning and text selection required for mask functionality.
 *
 * @example
 * ```html
 * <igx-input-group>
 *   <input type="text" igxInput [igxDateTimeEditor]="'dd/MM/yyyy'" [displayFormat]="'shortDate'" [(ngModel)]="date"/>
 * </igx-input-group>
 * ```
 */
declare class IgxDateTimeEditorDirective extends IgxMaskDirective implements OnChanges, OnInit, Validator, ControlValueAccessor {
    private _document;
    private _locale;
    /**
     * Locale settings used for value formatting.
     *
     * @remarks
     * Uses Angular's `LOCALE_ID` by default. Affects both input mask and display format if those are not set.
     * If a `locale` is set, it must be registered via `registerLocaleData`.
     * Please refer to https://angular.io/guide/i18n#i18n-pipes.
     * If it is not registered, `Intl` will be used for formatting.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [locale]="'en'">
     * ```
     */
    locale: string;
    /**
     * Minimum value required for the editor to remain valid.
     *
     * @remarks
     * If a `string` value is passed, it must be in the defined input format.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [minValue]="minDate">
     * ```
     */
    get minValue(): string | Date;
    set minValue(value: string | Date);
    /**
     * Maximum value required for the editor to remain valid.
     *
     * @remarks
     * If a `string` value is passed in, it must be in the defined input format.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [maxValue]="maxDate">
     * ```
     */
    get maxValue(): string | Date;
    set maxValue(value: string | Date);
    /**
     * Specify if the currently spun date segment should loop over.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [spinLoop]="false">
     * ```
     */
    spinLoop: boolean;
    /**
     * Set both pre-defined format options such as `shortDate` and `longDate`,
     * as well as constructed format string using characters supported by `DatePipe`, e.g. `EE/MM/yyyy`.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [displayFormat]="'shortDate'">
     * ```
     */
    set displayFormat(value: string);
    get displayFormat(): string;
    /**
     * Expected user input format (and placeholder).
     *
     * @example
     * ```html
     * <input [igxDateTimeEditor]="'dd/MM/yyyy'">
     * ```
     */
    set inputFormat(value: string);
    get inputFormat(): string;
    /**
     * Editor value.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [value]="date">
     * ```
     */
    set value(value: Date | string | undefined | null);
    get value(): Date | string | undefined | null;
    /**
     * Specify the default input format type. Defaults to `date`, which includes
     * only date parts for editing. Other valid options are `time` and `dateTime`.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [defaultFormatType]="'dateTime'">
     * ```
     */
    defaultFormatType: 'date' | 'time' | 'dateTime';
    /**
     * Delta values used to increment or decrement each editor date part on spin actions.
     * All values default to `1`.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [spinDelta]="{date: 5, minute: 30}">
     * ```
     */
    spinDelta: DatePartDeltas;
    /**
     * Emitted when the editor's value has changed.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor (valueChange)="valueChange($event)"/>
     * ```
     */
    valueChange: EventEmitter<string | Date>;
    /**
     * Emitted when the editor is not within a specified range or when the editor's value is in an invalid state.
     *
     * @example
     * ```html
     * <input igxDateTimeEditor [minValue]="minDate" [maxValue]="maxDate" (validationFailed)="onValidationFailed($event)"/>
     * ```
     */
    validationFailed: EventEmitter<IgxDateTimeEditorEventArgs>;
    private readonly SCROLL_THRESHOLD;
    private _inputFormat;
    private _scrollAccumulator;
    private _displayFormat;
    private _oldValue;
    private _dateValue;
    private _onClear;
    private document;
    private _defaultInputFormat;
    private _value?;
    private _minValue;
    private _maxValue;
    private _inputDateParts;
    private _datePartDeltas;
    private onChangeCallback;
    private _onValidatorChange;
    private get datePartDeltas();
    private get emptyMask();
    private get targetDatePart();
    private get hasDateParts();
    private get hasTimeParts();
    private get dateValue();
    constructor();
    onWheel(event: WheelEvent): void;
    ngOnInit(): void;
    /** @hidden @internal */
    ngOnChanges(changes: SimpleChanges): void;
    /** Clear the input element value. */
    clear(): void;
    /**
     * Increment specified DatePart.
     *
     * @param datePart The optional DatePart to increment. Defaults to Date or Hours (when Date is absent from the inputFormat - ex:'HH:mm').
     * @param delta The optional delta to increment by. Overrides `spinDelta`.
     */
    increment(datePart?: DatePart, delta?: number): void;
    /**
     * Decrement specified DatePart.
     *
     * @param datePart The optional DatePart to decrement. Defaults to Date or Hours (when Date is absent from the inputFormat - ex:'HH:mm').
     * @param delta The optional delta to decrement by. Overrides `spinDelta`.
     */
    decrement(datePart?: DatePart, delta?: number): void;
    /** @hidden @internal */
    writeValue(value: any): void;
    /** @hidden @internal */
    validate(control: AbstractControl): ValidationErrors | null;
    /** @hidden @internal */
    registerOnValidatorChange?(fn: () => void): void;
    /** @hidden @internal */
    registerOnChange(fn: any): void;
    /** @hidden @internal */
    registerOnTouched(fn: any): void;
    /** @hidden @internal */
    setDisabledState?(_isDisabled: boolean): void;
    /** @hidden @internal */
    onCompositionEnd(): void;
    /** @hidden @internal */
    onInputChanged(event: any): void;
    /** @hidden @internal */
    onKeyDown(event: KeyboardEvent): void;
    /** @hidden @internal */
    onFocus(): void;
    /** @hidden @internal */
    onBlur(event: FocusEvent): void;
    /** @hidden */
    protected setPlaceholder(_value: string): void;
    private updateDefaultFormat;
    private updateMask;
    private setMask;
    private parseDate;
    private getMaskedValue;
    private valueInRange;
    private spinValue;
    private trySpinValue;
    private setDateValue;
    private updateValue;
    private toTwelveHourFormat;
    private getPartValue;
    private prependValue;
    private spin;
    private inputIsComplete;
    private moveCursor;
    /**
     * Move the cursor in a specific direction until it reaches a date/time separator.
     * Then return its index.
     *
     * @param value The string it operates on.
     * @param direction 0 is left, 1 is right. Default is 0.
     */
    private getNewPosition;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDateTimeEditorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxDateTimeEditorDirective, "[igxDateTimeEditor]", ["igxDateTimeEditor"], { "locale": { "alias": "locale"; "required": false; }; "minValue": { "alias": "minValue"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; "spinLoop": { "alias": "spinLoop"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "inputFormat": { "alias": "igxDateTimeEditor"; "required": false; }; "value": { "alias": "value"; "required": false; }; "defaultFormatType": { "alias": "defaultFormatType"; "required": false; }; "spinDelta": { "alias": "spinDelta"; "required": false; }; }, { "valueChange": "valueChange"; "validationFailed": "validationFailed"; }, never, never, true, never>;
    static ngAcceptInputType_spinLoop: unknown;
}

declare class IgcFormControlDirective implements ControlValueAccessor {
    private elementRef;
    private renderer;
    /** @hidden @internal */
    private onChange;
    /** @hidden @internal */
    private onTouched;
    /** @hidden @internal */
    onBlur(): void;
    /** @hidden @internal */
    listenForValueChange(value: any): void;
    /** @hidden @internal */
    writeValue(value: any): void;
    /** @hidden @internal */
    registerOnChange(fn: any): void;
    /** @hidden @internal */
    registerOnTouched(fn: any): void;
    /** @hidden @internal */
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgcFormControlDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgcFormControlDirective, "igc-rating[ngModel],igc-rating[formControlName]", never, {}, {}, never, never, true, never>;
}

declare abstract class IgxNotificationsDirective extends IgxToggleDirective implements IToggleView, OnDestroy {
    /**
     * Sets/gets the `aria-live` attribute.
     * If not set, `aria-live` will have value `"polite"`.
     */
    ariaLive: string;
    /**
     * Sets/gets whether the element will be hidden after the `displayTime` is over.
     * Default value is `true`.
     */
    autoHide: boolean;
    /**
     * Sets/gets the duration of time span (in milliseconds) which the element will be visible
     * after it is being shown.
     * Default value is `4000`.
     */
    displayTime: number;
    /**
     * Gets/Sets the container used for the element.
     *
     * @remarks
     *  `outlet` is an instance of `IgxOverlayOutletDirective` or an `ElementRef`.
     */
    outlet: IgxOverlayOutletDirective | ElementRef<HTMLElement>;
    /**
     * Enables/Disables the visibility of the element.
     * If not set, the `isVisible` attribute will have value `false`.
     */
    get isVisible(): boolean;
    set isVisible(value: boolean);
    /**
     * @hidden
     * @internal
     */
    textMessage: string;
    /**
     * @hidden
     */
    timeoutId: number;
    /**
     * @hidden
     */
    protected strategy: IPositionStrategy;
    /**
     * @hidden
     */
    open(): void;
    /**
     * Hides the element.
     */
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxNotificationsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxNotificationsDirective, never, never, { "ariaLive": { "alias": "ariaLive"; "required": false; }; "autoHide": { "alias": "autoHide"; "required": false; }; "displayTime": { "alias": "displayTime"; "required": false; }; "outlet": { "alias": "outlet"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_autoHide: unknown;
    static ngAcceptInputType_isVisible: unknown;
}

declare class IgxTextHighlightService {
    highlightGroupsMap: Map<string, IActiveHighlightInfo>;
    onActiveElementChanged: EventEmitter<string>;
    constructor();
    /**
     * Activates the highlight at a given index.
     * (if such index exists)
     */
    setActiveHighlight(groupName: string, highlight: IActiveHighlightInfo): void;
    /**
     * Clears any existing highlight.
     */
    clearActiveHighlight(groupName: any): void;
    /**
     * Destroys a highlight group.
     */
    destroyGroup(groupName: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTextHighlightService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxTextHighlightService>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxButtonModule, never, [typeof IgxButtonDirective, typeof IgxIconButtonDirective], [typeof IgxButtonDirective, typeof IgxIconButtonDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxButtonModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxDateTimeEditorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDateTimeEditorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxDateTimeEditorModule, never, [typeof IgxDateTimeEditorDirective], [typeof IgxDateTimeEditorDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxDateTimeEditorModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxDividerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDividerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxDividerModule, never, [typeof IgxDividerDirective], [typeof IgxDividerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxDividerModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxDragDropModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDragDropModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxDragDropModule, never, [typeof IgxDragDirective, typeof IgxDropDirective, typeof IgxDragHandleDirective, typeof IgxDragIgnoreDirective], [typeof IgxDragDirective, typeof IgxDropDirective, typeof IgxDragHandleDirective, typeof IgxDragIgnoreDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxDragDropModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxFilterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFilterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxFilterModule, never, [typeof IgxFilterDirective, typeof IgxFilterPipe], [typeof IgxFilterDirective, typeof IgxFilterPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxFilterModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxFocusModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFocusModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxFocusModule, never, [typeof IgxFocusDirective], [typeof IgxFocusDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxFocusModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxFocusTrapModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFocusTrapModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxFocusTrapModule, never, [typeof IgxFocusTrapDirective], [typeof IgxFocusTrapDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxFocusTrapModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxForOfModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxForOfModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxForOfModule, never, [typeof IgxForOfDirective], [typeof IgxForOfDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxForOfModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgcFormsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgcFormsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgcFormsModule, never, [typeof IgcFormControlDirective], [typeof IgcFormControlDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgcFormsModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxLayoutModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxLayoutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxLayoutModule, never, [typeof IgxFlexDirective, typeof IgxLayoutDirective], [typeof IgxFlexDirective, typeof IgxLayoutDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxLayoutModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxMaskModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxMaskModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxMaskModule, never, [typeof IgxMaskDirective], [typeof IgxMaskDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxMaskModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxRippleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxRippleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxRippleModule, never, [typeof IgxRippleDirective], [typeof IgxRippleDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxRippleModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxScrollInertiaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxScrollInertiaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxScrollInertiaModule, never, [typeof IgxScrollInertiaDirective], [typeof IgxScrollInertiaDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxScrollInertiaModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxTextHighlightModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTextHighlightModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxTextHighlightModule, never, [typeof IgxTextHighlightDirective], [typeof IgxTextHighlightDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxTextHighlightModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxTextSelectionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTextSelectionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxTextSelectionModule, never, [typeof IgxTextSelectionDirective], [typeof IgxTextSelectionDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxTextSelectionModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxToggleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxToggleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxToggleModule, never, [typeof IgxToggleDirective, typeof IgxToggleActionDirective], [typeof IgxToggleDirective, typeof IgxToggleActionDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxToggleModule>;
}

/**
 * @hidden
 * IMPORTANT: The following is NgModule exported for backwards-compatibility before standalone components
 */
declare class IgxTooltipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxTooltipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<IgxTooltipModule, never, [typeof IgxTooltipDirective, typeof IgxTooltipTargetDirective], [typeof IgxTooltipDirective, typeof IgxTooltipTargetDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<IgxTooltipModule>;
}

export { CheckboxBaseDirective, DragDirection, IGX_DRAG_DROP_DIRECTIVES, IGX_TOOLTIP_DIRECTIVES, IgSizeDirective, IgcFormControlDirective, IgcFormsModule, IgxAppendDropStrategy, IgxButtonDirective, IgxButtonModule, IgxButtonType, IgxDateTimeEditorDirective, IgxDateTimeEditorModule, IgxDefaultDropStrategy, IgxDividerDirective, IgxDividerModule, IgxDividerType, IgxDragDirective, IgxDragDropModule, IgxDragHandleDirective, IgxDragIgnoreDirective, IgxDragLocation, IgxDropDirective, IgxFilterDirective, IgxFilterModule, IgxFilterOptions, IgxFilterPipe, IgxFlexDirective, IgxFocusDirective, IgxFocusModule, IgxFocusTrapDirective, IgxFocusTrapModule, IgxForOfContext, IgxForOfDirective, IgxForOfModule, IgxForOfScrollSyncService, IgxForOfSyncService, IgxForOfToken, IgxGridForOfContext, IgxGridForOfDirective, IgxIconButtonDirective, IgxInsertDropStrategy, IgxLayoutDirective, IgxLayoutModule, IgxMaskDirective, IgxMaskModule, IgxNotificationsDirective, IgxPrependDropStrategy, IgxRippleDirective, IgxRippleModule, IgxScrollInertiaDirective, IgxScrollInertiaModule, IgxTemplateOutletDirective, IgxTextHighlightDirective, IgxTextHighlightModule, IgxTextHighlightService, IgxTextSelectionDirective, IgxTextSelectionModule, IgxToggleActionDirective, IgxToggleDirective, IgxToggleModule, IgxTooltipDirective, IgxTooltipModule, IgxTooltipTargetDirective, LabelPosition, TooltipPositionStrategy };
export type { ArrowFit, IActiveHighlightInfo, IBaseSearchInfo, IButtonEventArgs, ICachedViewLoadedEventArgs, IChangeCheckboxEventArgs, IDragBaseEventArgs, IDragCustomTransitionArgs, IDragGhostBaseEventArgs, IDragMoveEventArgs, IDragStartEventArgs, IDropBaseEventArgs, IDropDroppedEventArgs, IDropStrategy, IForOfDataChangeEventArgs, IForOfDataChangingEventArgs, IForOfState, IMaskEventArgs, ITooltipHideEventArgs, ITooltipShowEventArgs, IViewChangeEventArgs, IgxDateTimeEditorEventArgs, IgxDragCustomEventDetails, IgxIconButtonType, ToggleViewCancelableEventArgs, ToggleViewEventArgs };