import * as i0 from '@angular/core';
import { InjectionToken, EventEmitter, OnDestroy, ElementRef, Type, ViewContainerRef, ComponentRef, Injector, NgZone, ChangeDetectorRef, QueryList, TemplateRef } from '@angular/core';
import * as rxjs from 'rxjs';
import { BehaviorSubject, Observable } from 'rxjs';
import { AnimationReferenceMetadata, AnimationPlayer as AnimationPlayer$1 } from '@angular/animations';
import { ValidationErrors } from '@angular/forms';

/**
 * Common interface for Components with show and collapse functionality
 */
interface IToggleView {
    element: any;
    open(...args: any[]): any;
    close(...args: any[]): any;
    toggle(...args: any[]): any;
}

/**
 * Common service to be injected between components where those implementing common
 * ToggleView interface can register and toggle directives can call their methods.
 * TODO: Track currently active? Events?
 */
declare class IgxNavigationService {
    private navs;
    constructor();
    add(id: string, navItem: IToggleView): void;
    remove(id: string): void;
    get(id: string): IToggleView;
    toggle(id: string, ...args: any[]): any;
    open(id: string, ...args: any[]): any;
    close(id: string, ...args: any[]): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxNavigationService>;
}

/**
 * Directive that can toggle targets through provided NavigationService.
 *
 * Usage:
 * ```
 * <button type="button" igxNavToggle="ID">Toggle</button>
 * ```
 * Where the `ID` matches the ID of compatible `IToggleView` component.
 */
declare class IgxNavigationToggleDirective {
    private target;
    state: IgxNavigationService;
    constructor();
    toggleNavigationDrawer(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxNavigationToggleDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxNavigationToggleDirective, "[igxNavToggle]", never, { "target": { "alias": "igxNavToggle"; "required": false; }; }, {}, never, never, true, never>;
}
/**
 * Directive that can close targets through provided NavigationService.
 *
 * Usage:
 * ```
 * <button type="button" igxNavClose="ID">Close</button>
 * ```
 * Where the `ID` matches the ID of compatible `IToggleView` component.
 */
declare class IgxNavigationCloseDirective {
    private target;
    state: IgxNavigationService;
    constructor();
    closeNavigationDrawer(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxNavigationCloseDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxNavigationCloseDirective, "[igxNavClose]", never, { "target": { "alias": "igxNavClose"; "required": false; }; }, {}, never, never, true, never>;
}

interface DateRangeDescriptor {
    type: DateRangeType;
    dateRange?: Date[];
}
declare enum DateRangeType {
    After = 0,
    Before = 1,
    Between = 2,
    Specific = 3,
    Weekdays = 4,
    Weekends = 5
}

/**
 * @hidden @internal
 *
 * Enumeration representing the possible predefined size options of the grid.
 * - Small: This is the smallest size with 32px row height. Left and Right paddings are 12px. Minimal column width is 56px.
 * - Medium: This is the middle size with 40px row height. Left and Right paddings are 16px. Minimal column width is 64px.
 * - Large:  this is the default Grid size with the lowest intense and row height equal to 50px. Left and Right paddings are 24px. Minimal column width is 80px.
 */
declare const Size$1: {
    readonly Small: "1";
    readonly Medium: "2";
    readonly Large: "3";
};
type Size$1 = (typeof Size$1)[keyof typeof Size$1];
/**
 * Enumeration representing the days of the week.
 */
declare enum WEEKDAYS {
    SUNDAY = 0,
    MONDAY = 1,
    TUESDAY = 2,
    WEDNESDAY = 3,
    THURSDAY = 4,
    FRIDAY = 5,
    SATURDAY = 6
}

declare class ThemeToken {
    private t?;
    private document;
    subject: BehaviorSubject<IgxTheme>;
    constructor(t?: IgxTheme);
    onChange(callback: (theme: IgxTheme) => void): rxjs.Subscription;
    set(theme: IgxTheme): void;
    get theme(): IgxTheme;
    get preferToken(): boolean;
}
declare const THEME_TOKEN: InjectionToken<ThemeToken>;
declare const Theme: {
    readonly Material: "material";
    readonly Fluent: "fluent";
    readonly Bootstrap: "bootstrap";
    readonly IndigoDesign: "indigo";
};
/**
 * Determines the component theme.
 */
type IgxTheme = (typeof Theme)[keyof typeof Theme];

/** @hidden @internal */
declare const ELEMENTS_TOKEN: InjectionToken<boolean>;
/**
 * @hidden
 */
declare const showMessage: (message: string, isMessageShown: boolean) => boolean;
/**
 *
 * @hidden @internal
 */
declare const getResizeObserver: () => {
    new (callback: ResizeObserverCallback): ResizeObserver;
    prototype: ResizeObserver;
};
/**
 * @hidden
 */
declare function cloneArray<T>(array: T[], deep?: boolean): T[];
/**
 * @hidden
 */
declare function areEqualArrays<T>(arr1: T[], arr2: T[]): boolean;
/**
 * Doesn't clone leaf items
 *
 * @hidden
 */
declare const cloneHierarchicalArray: (array: any[], childDataKey: any) => any[];
/**
 * Creates an object with prototype from provided source and copies
 * all properties descriptors from provided source
 * @param obj Source to copy prototype and descriptors from
 * @returns New object with cloned prototype and property descriptors
 */
declare const copyDescriptors: (obj: any) => any;
/**
 * Deep clones all first level keys of Obj2 and merges them to Obj1
 *
 * @param obj1 Object to merge into
 * @param obj2 Object to merge from
 * @returns Obj1 with merged cloned keys from Obj2
 * @hidden
 */
declare const mergeObjects: (obj1: any, obj2: any) => any;
/**
 * Creates deep clone of provided value.
 * Supports primitive values, dates and objects.
 * If passed value is array returns shallow copy of the array.
 *
 * @param value value to clone
 * @returns Deep copy of provided value
 * @hidden
 */
declare const cloneValue: (value: any) => any;
/**
 * Creates deep clone of provided value.
 * Supports primitive values, dates and objects.
 * If passed value is array returns shallow copy of the array.
 * For Objects property values and references are cached and reused.
 * This allows for circular references to same objects.
 *
 * @param value value to clone
 * @param cache map of cached values already parsed
 * @returns Deep copy of provided value
 * @hidden
 */
declare const cloneValueCached: (value: any, cache: Map<any, any>) => any;
/**
 * Parse provided input to Date.
 *
 * @param value input to parse
 * @returns Date if parse succeed or null
 * @hidden
 */
declare const parseDate: (value: any) => Date | null;
/**
 * Returns an array with unique dates only.
 *
 * @param columnValues collection of date values (might be numbers or ISO 8601 strings)
 * @returns collection of unique dates.
 * @hidden
 */
declare const uniqueDates: (columnValues: any[]) => any;
/**
 * Checks if provided variable is Object
 *
 * @param value Value to check
 * @returns true if provided variable is Object
 * @hidden
 */
declare const isObject: (value: any) => boolean;
/**
 * Checks if provided variable is Date
 *
 * @param value Value to check
 * @returns true if provided variable is Date
 * @hidden
 */
declare const isDate: (value: any) => value is Date;
/**
 * Checks if the two passed arguments are equal
 * Currently supports date objects
 *
 * @param obj1
 * @param obj2
 * @returns: `boolean`
 * @hidden
 */
declare const isEqual: (obj1: any, obj2: any) => boolean;
/**
 * Limits a number to a range between a minimum and a maximum value.
 *
 * @param number
 * @param min
 * @param max
 * @returns: `number`
 * @hidden
 */
declare const clamp: (number: number, min: number, max: number) => number;
/**
 * Utility service taking care of various utility functions such as
 * detecting browser features, general cross browser DOM manipulation, etc.
 *
 * @hidden @internal
 */
declare class PlatformUtil {
    private platformId;
    isBrowser: boolean;
    isIOS: boolean;
    isSafari: boolean;
    isFirefox: boolean;
    isEdge: boolean;
    isChromium: boolean;
    browserVersion: number;
    /** @hidden @internal */
    isElements: boolean;
    KEYMAP: {
        readonly ENTER: "Enter";
        readonly SPACE: " ";
        readonly ESCAPE: "Escape";
        readonly ARROW_DOWN: "ArrowDown";
        readonly ARROW_UP: "ArrowUp";
        readonly ARROW_LEFT: "ArrowLeft";
        readonly ARROW_RIGHT: "ArrowRight";
        readonly END: "End";
        readonly HOME: "Home";
        readonly PAGE_DOWN: "PageDown";
        readonly PAGE_UP: "PageUp";
        readonly F2: "F2";
        readonly TAB: "Tab";
        readonly SEMICOLON: ";";
        readonly DELETE: "Delete";
        readonly BACKSPACE: "Backspace";
        readonly CONTROL: "Control";
        readonly X: "x";
        readonly Y: "y";
        readonly Z: "z";
    };
    /**
     * @hidden @internal
     * Returns the actual size of the node content, using Range
     * ```typescript
     * let range = document.createRange();
     * let column = this.grid.columnList.filter(c => c.field === 'ID')[0];
     *
     * let size = getNodeSizeViaRange(range, column.cells[0].nativeElement);
     *
     * @remarks
     * The last parameter is useful when the size of the element to measure is modified by a
     * parent element that has explicit size. In such cases the calculated size is never lower
     * and the function may instead remove the parent size while measuring to get the correct value.
     * ```
     */
    getNodeSizeViaRange(range: Range, node: HTMLElement, sizeHoldingNode?: HTMLElement): number;
    /**
     * Returns true if the current keyboard event is an activation key (Enter/Space bar)
     *
     * @hidden
     * @internal
     *
     * @memberof PlatformUtil
     */
    isActivationKey(event: KeyboardEvent): boolean;
    /**
     * Returns true if the current keyboard event is a combination that closes the filtering UI of the grid. (Escape/Ctrl+Shift+L)
     *
     * @hidden
     * @internal
     * @param event
     * @memberof PlatformUtil
     */
    isFilteringKeyCombo(event: KeyboardEvent): boolean;
    /**
     * @hidden @internal
     */
    isLeftClick(event: PointerEvent | MouseEvent): boolean;
    /**
     * @hidden @internal
     */
    isNavigationKey(key: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformUtil, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformUtil>;
}
/**
 * @hidden
 */
declare const flatten: (arr: any[]) => any[];
interface CancelableEventArgs {
    /**
     * Provides the ability to cancel the event.
     */
    cancel: boolean;
}
interface IBaseEventArgs {
    /**
     * Provides reference to the owner component.
     */
    owner?: any;
}
interface CancelableBrowserEventArgs extends CancelableEventArgs {
    /** Browser event */
    event?: Event;
}
interface IBaseCancelableBrowserEventArgs extends CancelableBrowserEventArgs, IBaseEventArgs {
}
interface IBaseCancelableEventArgs extends CancelableEventArgs, IBaseEventArgs {
}
declare const HORIZONTAL_NAV_KEYS: Set<string>;
declare const NAVIGATION_KEYS: Set<string>;
declare const ACCORDION_NAVIGATION_KEYS: Set<string>;
declare const ROW_EXPAND_KEYS: Set<string>;
declare const ROW_COLLAPSE_KEYS: Set<string>;
declare const ROW_ADD_KEYS: Set<string>;
declare const SUPPORTED_KEYS: Set<string>;
declare const HEADER_KEYS: Set<string>;
/**
 * @hidden
 * @internal
 *
 * Creates a new ResizeObserver on `target` and returns it as an Observable.
 * Run the resizeObservable outside angular zone, because it patches the MutationObserver which causes an infinite loop.
 * Related issue: https://github.com/angular/angular/issues/31712
 */
declare const resizeObservable: (target: HTMLElement) => Observable<ResizeObserverEntry[]>;
/**
 * @hidden
 * @internal
 *
 * Compares two maps.
 */
declare const compareMaps: (map1: Map<any, any>, map2: Map<any, any>) => boolean;
declare function columnFieldPath(path?: string): string[];
/**
 * Given a property access path in the format `x.y.z` resolves and returns
 * the value of the `z` property in the passed object.
 *
 * @hidden
 * @internal
 */
declare function resolveNestedPath<T extends object, U>(obj: unknown, pathParts: string[], defaultValue?: U): T | U | undefined;
/**
 *
 * Given a property access path in the format `x.y.z` and a value
 * this functions builds and returns an object following the access path.
 *
 * @example
 * ```typescript
 * console.log('x.y.z.', 42);
 * >> { x: { y: { z: 42 } } }
 * ```
 *
 * @hidden
 * @internal
 */
declare const reverseMapper: (path: string, value: any) => {};
declare const yieldingLoop: (count: number, chunkSize: number, callback: (index: number) => void, done: () => void) => void;
declare const isConstructor: (ref: any) => boolean;
/**
 * Similar to Angular's formatDate. However it will not throw on `undefined | null | ''` instead
 * coalescing to an empty string.
 */
declare const formatDate: (value: string | number | Date, format: string, locale: string, timezone?: string) => string;
declare const formatCurrency: {
    (value: number | string, currencyCode?: string, display?: "code" | "symbol" | "symbol-narrow" | string | boolean, digitsInfo?: string, locale?: string): string | null;
    (value: null | undefined, currencyCode?: string, display?: "code" | "symbol" | "symbol-narrow" | string | boolean, digitsInfo?: string, locale?: string): null;
    (value: number | string | null | undefined, currencyCode?: string, display?: "code" | "symbol" | "symbol-narrow" | string | boolean, digitsInfo?: string, locale?: string): string | null;
};
/** Converts pixel values to their rem counterparts for a base value */
declare const rem: (value: number | string) => number;
/** Get the size of the component as derived from the CSS size variable */
declare function getComponentSize(el: Element): string;
/** Get the first item in an array */
declare function first<T>(arr: T[]): T;
/** Get the last item in an array */
declare function last<T>(arr: T[]): T;
/** Calculates the modulo of two numbers, ensuring a non-negative result. */
declare function modulo(n: number, d: number): number;
/**
 * Splits an array into chunks of length `size` and returns a generator
 * yielding each chunk.
 * The last chunk may contain less than `size` elements.
 *
 * @example
 * ```typescript
 * const arr = [0,1,2,3,4,5,6,7,8,9];
 *
 * Array.from(chunk(arr, 2)) // [[0, 1], [2, 3], [4, 5], [6, 7], [8, 9]]
 * Array.from(chunk(arr, 3)) // [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]
 * Array.from(chunk([], 3)) // []
 * Array.from(chunk(arr, -3)) // Error
 * ```
 */
declare function intoChunks<T>(arr: T[], size: number): Generator<T[], void, unknown>;
/**
 * @param size
 * @returns string that represents the --component-size default value
 */
declare function getComponentCssSizeVar(size: string): "var(--ig-size, var(--ig-size-small))" | "var(--ig-size, var(--ig-size-medium))" | "var(--ig-size, var(--ig-size-large))";
/**
 * @param path - The URI path to be normalized.
 * @returns string encoded using the encodeURI function.
 */
declare function normalizeURI(path: string): string;
declare function getComponentTheme(el: Element): IgxTheme;
/**
 * Collection re-created w/ the built in track by identity will always log
 * warning even for valid cases of recalculating all collection items.
 * See https://github.com/angular/angular/blob/55581b4181639568fb496e91055142a1b489e988/packages/core/src/render3/instructions/control_flow.ts#L393-L409
 * Current solution explicit track function doing the same as suggested in:
 * https://github.com/angular/angular/issues/56471#issuecomment-2180315803
 * This should be used with moderation and when necessary.
 * @internal
 */
declare function trackByIdentity<T>(item: T): T;

type KeyOfOrString<T, K = keyof T> = K extends keyof T ? K : string;

/** @hidden */
declare class IgxSelectionAPIService {
    /**
     * If primaryKey is defined, then multiple selection is based on the primaryKey, and it is array of numbers, strings, etc.
     * If the primaryKey is omitted, then selection is based on the item data
     */
    protected selection: Map<string, Set<any>>;
    /**
     * Get current component selection.
     *
     * @param componentID ID of the component.
     */
    get(componentID: string): Set<any>;
    /**
     * Set new component selection.
     *
     * @param componentID ID of the component.
     * @param newSelection The new component selection to be set.
     */
    set(componentID: string, newSelection: Set<any>): void;
    /**
     * Clears selection for component.
     *
     * @param componentID ID of the component.
     */
    clear(componentID: string): void;
    /**
     * Removes selection for a component.
     * @param componentID
     */
    delete(componentID: string): void;
    /**
     * Get current component selection length.
     *
     * @param componentID ID of the component.
     */
    size(componentID: string): number;
    /**
     * Creates new selection that consist of the new item added to the current component selection.
     * The returned collection is new Set,
     * therefore if you want to update component selection you need to call in addition the set_selection() method
     * or instead use the select_item() one.
     *
     * @param componentID ID of the component, which we add new item to.
     * @param itemID ID of the item to add to component selection.
     * @param sel Used internally only by the selection (add_items method) to accumulate selection for multiple items.
     *
     * @returns Selection after the new item is added.
     */
    add_item(componentID: string, itemID: any, sel?: Set<any>): Set<any>;
    /**
     * Creates new selection that consist of the new items added to the current component selection.
     * The returned collection is new Set,
     * therefore if you want to update component selection you need to call in addition the set_selection() method
     * or instead use the select_items() one.
     *
     * @param componentID ID of the component, which we add new items to.
     * @param itemIDs Array of IDs of the items to add to component selection.
     * @param clearSelection If true it will clear previous selection.
     *
     * @returns Selection after the new items are added.
     */
    add_items(componentID: string, itemIDs: any[], clearSelection?: boolean): Set<any>;
    /**
     * Add item to the current component selection.
     *
     * @param componentID ID of the component, which we add new item to.
     * @param itemID ID of the item to add to component selection.
     * @param sel Used internally only by the selection (select_items method) to accumulate selection for multiple items.
     */
    select_item(componentID: string, itemID: any, sel?: Set<any>): void;
    /**
     * Add items to the current component selection.
     *
     * @param componentID ID of the component, which we add new items to.
     * @param itemIDs Array of IDs of the items to add to component selection.
     * @param clearSelection If true it will clear previous selection.
     */
    select_items(componentID: string, itemID: any[], clearSelection?: boolean): void;
    /**
     * Creates new selection that consist of the new items excluded from the current component selection.
     * The returned collection is new Set,
     * therefore if you want to update component selection you need to call in addition the set_selection() method
     * or instead use the deselect_item() one.
     *
     * @param componentID ID of the component, which we remove items from.
     * @param itemID ID of the item to remove from component selection.
     * @param sel Used internally only by the selection (delete_items method) to accumulate deselected items.
     *
     * @returns Selection after the item is removed.
     */
    delete_item(componentID: string, itemID: any, sel?: Set<any>): Set<any>;
    /**
     * Creates new selection that consist of the new items removed to the current component selection.
     * The returned collection is new Set,
     * therefore if you want to update component selection you need to call in addition the set_selection() method
     * or instead use the deselect_items() one.
     *
     * @param componentID ID of the component, which we remove items from.
     * @param itemID ID of the items to remove from component selection.
     *
     * @returns Selection after the items are removed.
     */
    delete_items(componentID: string, itemIDs: any[]): Set<any>;
    /**
     * Remove item from the current component selection.
     *
     * @param componentID ID of the component, which we remove item from.
     * @param itemID ID of the item to remove from component selection.
     * @param sel Used internally only by the selection (deselect_items method) to accumulate selection for multiple items.
     */
    deselect_item(componentID: string, itemID: any, sel?: Set<any>): void;
    /**
     * Remove items to the current component selection.
     *
     * @param componentID ID of the component, which we add new items to.
     * @param itemIDs Array of IDs of the items to add to component selection.
     */
    deselect_items(componentID: string, itemID: any[], _clearSelection?: boolean): void;
    /**
     * Check if the item is selected in the component selection.
     *
     * @param componentID ID of the component.
     * @param itemID ID of the item to search.
     *
     * @returns If item is selected.
     */
    is_item_selected(componentID: string, itemID: any): boolean;
    /**
     * Get first element in the selection.
     * This is correct when we have only one item in the collection (for single selection purposes)
     * and the method returns that item.
     *
     * @param componentID ID of the component.
     *
     * @returns First element in the set.
     */
    first_item(componentID: string): any;
    /**
     * Returns whether all items are selected.
     *
     * @param componentID ID of the component.
     * @param dataCount: number Number of items in the data.
     *
     * @returns If all items are selected.
     */
    are_all_selected(componentID: string, dataCount: number): boolean;
    /**
     * Returns whether any of the items is selected.
     *
     * @param componentID ID of the component.
     * @param data Entire data array.
     *
     * @returns If there is any item selected.
     */
    are_none_selected(componentID: string): boolean;
    /**
     * Get all primary key values from a data array. If there isn't a primary key defined that the entire data is returned instead.
     *
     * @param data Entire data array.
     * @param primaryKey Data primary key.
     *
     * @returns Array of identifiers, either primary key values or the entire data array.
     */
    get_all_ids(data: any, primaryKey?: any): any;
    /**
     * Returns empty selection collection.
     *
     * @returns empty set.
     */
    get_empty(): Set<unknown>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxSelectionAPIService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxSelectionAPIService>;
}

/**
 * Used for editor control components
 *
 * @hidden
 */
interface EditorProvider {
    /** Return the focusable native element */
    getEditElement(): HTMLElement;
}
/**
 * Injection token is used to inject the EditorProvider token into components
 *
 * @hidden @internal
 */
declare const EDITOR_PROVIDER: InjectionToken<EditorProvider>;

/**
 * Stripped-down HammerJS annotations.
 */
/**
* @hidden
* @internal
*/
interface HammerInput {
    preventDefault: () => void;
    deltaX: number;
    deltaY: number;
    center: {
        x: number;
        y: number;
    };
    pointerType: string;
    distance: number;
}
/**
* @hidden
* @internal
*/
interface HammerStatic {
    new (element: HTMLElement | SVGElement, options?: any): HammerManager;
    Pan: Recognizer;
    Swipe: Recognizer;
    Tap: Recognizer;
    TouchInput: HammerInput;
    DIRECTION_HORIZONTAL: number;
    DIRECTION_VERTICAL: number;
}
/**
* @hidden
* @internal
*/
interface Recognizer {
}
/**
* @hidden
* @internal
*/
interface HammerManager {
    set(options: any): HammerManager;
    off(events: string, handler?: (event: HammerInput) => void): void;
    on(events: string, handler: (event: HammerInput) => void): void;
    destroy(): void;
    get(event: string): HammerManager;
}
/**
* @hidden
* @internal
*/
interface HammerOptions {
    cssProps?: {
        [key: string]: string;
    };
    recognizers?: any[];
    inputClass?: HammerInput;
}

/**
 * Touch gestures manager based on Hammer.js
 * Use with caution, this will track references for single manager per element. Very TBD. Much TODO.
 *
 * @hidden
 */
declare class HammerGesturesManager {
    private _zone;
    private doc;
    private platformUtil;
    static Hammer: HammerStatic;
    /**
     * Event option defaults for each recognizer, see http://hammerjs.github.io/api/ for API listing.
     */
    protected hammerOptions: HammerOptions;
    private platformBrowser;
    private _hammerManagers;
    constructor();
    supports(eventName: string): boolean;
    /**
     * Add listener extended with options for Hammer.js. Will use defaults if none are provided.
     * Modeling after other event plugins for easy future modifications.
     */
    addEventListener(element: HTMLElement, eventName: string, eventHandler: (eventObj: any) => void, options?: HammerOptions): () => void;
    /**
     * Add listener extended with options for Hammer.js. Will use defaults if none are provided.
     * Modeling after other event plugins for easy future modifications.
     *
     * @param target Can be one of either window, body or document(fallback default).
     */
    addGlobalEventListener(target: string, eventName: string, eventHandler: (eventObj: any) => void): () => void;
    /**
     * Exposes [Dom]Adapter.getGlobalEventTarget to get global event targets.
     * Supported: window, document, body. Defaults to document for invalid args.
     *
     * @param target Target name
     */
    getGlobalEventTarget(target: string): EventTarget;
    /**
     * Set HammerManager options.
     *
     * @param element The DOM element used to create the manager on.
     *
     * ### Example
     *
     * ```ts
     * manager.setManagerOption(myElem, "pan", { pointers: 1 });
     * ```
     */
    setManagerOption(element: EventTarget, event: string, options: any): void;
    /**
     * Add an element and manager map to the internal collection.
     *
     * @param element The DOM element used to create the manager on.
     */
    addManagerForElement(element: EventTarget, manager: HammerManager): void;
    /**
     * Get HammerManager for the element or null
     *
     * @param element The DOM element used to create the manager on.
     */
    getManagerForElement(element: EventTarget): HammerManager;
    /**
     * Destroys the HammerManager for the element, removing event listeners in the process.
     *
     * @param element The DOM element used to create the manager on.
     */
    removeManagerForElement(element: HTMLElement): void;
    /** Destroys all internally tracked HammerManagers, removing event listeners in the process. */
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HammerGesturesManager, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HammerGesturesManager>;
}

interface AnimationService {
    /**
     * Creates an `AnimationPlayer` instance
     * @param animation A set of options describing the animation
     * @param element The DOM element on which animation will be applied
     * @returns AnimationPlayer
     */
    buildAnimation: (animationMetaData: AnimationReferenceMetadata, element: HTMLElement) => AnimationPlayer;
}
interface AnimationPlayer {
    /**
     * Emits when the animation starts
     */
    animationStart: EventEmitter<IBaseEventArgs>;
    /**
     * Emits when the animation ends
     */
    animationEnd: EventEmitter<IBaseEventArgs>;
    /**
     * Current position of the animation.
     */
    position: number;
    /**
     * Initialize the animation
    */
    init(): void;
    /**
     * Runs the animation
     */
    play(): void;
    /**
     * Ends the animation
     */
    finish(): void;
    /**
     * Resets the animation to its initial state
     */
    reset(): void;
    /**
     * Destroys the animation.
     */
    destroy(): void;
    /**
     * Reports whether the animation has started.
     */
    hasStarted(): boolean;
}

/**
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/overlay-position)
 * Position strategies determine where to display the component in the provided IgxOverlayService.
 */
interface IPositionStrategy {
    /**
     * PositionSettings to use when position the component in the overlay
     */
    settings: PositionSettings;
    /**
     * Position the element based on the PositionStrategy implementing this interface.
     *
     * @param contentElement The HTML element to be positioned
     * @param size Size of the element
     * @param document reference to the Document object
     * @param initialCall should be true if this is the initial call to the method
     * @param target attaching target for the component to show
     * ```typescript
     * settings.positionStrategy.position(content, size, document, true);
     * ```
     */
    position(contentElement: HTMLElement, size?: Size, document?: Document, initialCall?: boolean, target?: Point | HTMLElement): void;
    /**
     * Clone the strategy instance.
     * ```typescript
     * settings.positionStrategy.clone();
     * ```
     */
    clone(): IPositionStrategy;
}

/**
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/overlay-main)
 * The overlay service allows users to show components on overlay div above all other elements in the page.
 */
declare class IgxOverlayService implements OnDestroy {
    private _appRef;
    private document;
    private _zone;
    protected platformUtil: PlatformUtil;
    private animationService;
    /**
     * Emitted just before the overlay content starts to open.
     * ```typescript
     * opening(event: OverlayCancelableEventArgs){
     *     const opening = event;
     * }
     * ```
     */
    opening: EventEmitter<OverlayCancelableEventArgs>;
    /**
     * Emitted after the overlay content is opened and all animations are finished.
     * ```typescript
     * opened(event: OverlayEventArgs){
     *     const opened = event;
     * }
     * ```
     */
    opened: EventEmitter<OverlayEventArgs>;
    /**
     * Emitted just before the overlay content starts to close.
     * ```typescript
     * closing(event: OverlayCancelableEventArgs){
     *     const closing = event;
     * }
     * ```
     */
    closing: EventEmitter<OverlayClosingEventArgs>;
    /**
     * Emitted after the overlay content is closed and all animations are finished.
     * ```typescript
     * closed(event: OverlayEventArgs){
     *     const closed = event;
     * }
     * ```
     */
    closed: EventEmitter<OverlayEventArgs>;
    /**
     * Emitted before the content is appended to the overlay.
     * ```typescript
     * contentAppending(event: OverlayEventArgs){
     *     const contentAppending = event;
     * }
     * ```
     */
    contentAppending: EventEmitter<OverlayEventArgs>;
    /**
     * Emitted after the content is appended to the overlay, and before animations are started.
     * ```typescript
     * contentAppended(event: OverlayEventArgs){
     *     const contentAppended = event;
     * }
     * ```
     */
    contentAppended: EventEmitter<OverlayEventArgs>;
    /**
     * Emitted just before the overlay animation start.
     * ```typescript
     * animationStarting(event: OverlayAnimationEventArgs){
     *     const animationStarting = event;
     * }
     * ```
     */
    animationStarting: EventEmitter<OverlayAnimationEventArgs>;
    private _componentId;
    private _overlayInfos;
    private _overlayElement;
    private _document;
    private _keyPressEventListener;
    private destroy$;
    private _cursorStyleIsSet;
    private _cursorOriginalValue;
    private _defaultSettings;
    constructor();
    /**
     * Creates overlay settings with global or container position strategy and preset position settings
     *
     * @param position Preset position settings. Default position is 'center'
     * @param outlet The outlet container to attach the overlay to
     * @returns Non-modal overlay settings based on Global or Container position strategy and the provided position.
     */
    static createAbsoluteOverlaySettings(position?: AbsolutePosition, outlet?: IgxOverlayOutletDirective | ElementRef): OverlaySettings;
    /**
     * Creates overlay settings with auto, connected or elastic position strategy and preset position settings
     *
     * @param target Attaching target for the component to show
     * @param strategy The relative position strategy to be applied to the overlay settings. Default is Auto positioning strategy.
     * @param position Preset position settings. By default the element is positioned below the target, left aligned.
     * @returns Non-modal overlay settings based on the provided target, strategy and position.
     */
    static createRelativeOverlaySettings(target: Point | HTMLElement, position?: RelativePosition, strategy?: RelativePositionStrategy): OverlaySettings;
    private static createAbsolutePositionSettings;
    private static createRelativePositionSettings;
    private static createPositionStrategy;
    /**
     * Generates Id. Provide this Id when call `show(id)` method
     *
     * @param component ElementRef to show in overlay
     * @param settings (optional): Display settings for the overlay, such as positioning and scroll/close behavior.
     * @returns Id of the created overlay. Valid until `detach` is called.
     */
    attach(element: ElementRef, settings?: OverlaySettings): string;
    /**
     * Generates Id. Provide this Id when call `show(id)` method
     *
     * Note created instance is in root scope, prefer the `viewContainerRef` overload when local injection context is needed.
     *
     * @param component Component Type to show in overlay
     * @param settings (optional): Create settings for the overlay, such as positioning and scroll/close behavior.
     * Includes also an optional `Injector` to add to the created dynamic component's injectors.
     * @returns Id of the created overlay. Valid until `detach` is called.
     */
    attach(component: Type<any>, settings?: OverlayCreateSettings): string;
    /**
     * Generates an Id. Provide this Id when calling the `show(id)` method
     *
     * @param component Component Type to show in overlay
     * @param viewContainerRef Reference to the container where created component's host view will be inserted
     * @param settings (optional): Display settings for the overlay, such as positioning and scroll/close behavior.
     */
    attach(component: Type<any>, viewContainerRef: ViewContainerRef, settings?: OverlaySettings): string;
    /**
     * Remove overlay with the provided id.
     *
     * @param id Id of the overlay to remove
     * ```typescript
     * this.overlay.detach(id);
     * ```
     */
    detach(id: string): void;
    /**
     * Remove all the overlays.
     * ```typescript
     * this.overlay.detachAll();
     * ```
     */
    detachAll(): void;
    /**
     * Shows the overlay for provided id.
     *
     * @param id Id to show overlay for
     * @param settings Display settings for the overlay, such as positioning and scroll/close behavior.
     */
    show(id: string, settings?: OverlaySettings): void;
    /**
     * Hides the component with the ID provided as a parameter.
     * ```typescript
     * this.overlay.hide(id);
     * ```
     */
    hide(id: string, event?: Event): void;
    /**
     * Hides all the components and the overlay.
     * ```typescript
     * this.overlay.hideAll();
     * ```
     */
    hideAll(): void;
    /**
     * Repositions the component with ID provided as a parameter.
     *
     * @param id Id to reposition overlay for
     * ```typescript
     * this.overlay.reposition(id);
     * ```
     */
    reposition(id: string): 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
     *
     * @param id Id to offset overlay for
     * @param deltaX Amount of offset in horizontal direction
     * @param deltaY Amount of offset in vertical direction
     * @param offsetMode Determines whether to add (by default) or set the offset values with OffsetMode.Add and OffsetMode.Set
     * ```typescript
     * this.overlay.setOffset(id, deltaX, deltaY, offsetMode);
     * ```
     */
    setOffset(id: string, deltaX: number, deltaY: number, offsetMode?: OffsetMode): void;
    /** @hidden */
    repositionAll: () => void;
    /** @hidden */
    ngOnDestroy(): void;
    /** @hidden @internal */
    getOverlayById(id: string): OverlayInfo;
    private _hide;
    /**
     * Creates overlayInfo. Sets the info's `elementRef`, `componentRef`and `settings`. Also
     * initialize info's `ngZone`, `transformX` and `transformY`.
     * @param component ElementRef or Type. If type is provided dynamic component will be created
     * @param viewContainerRefOrSettings (optional): If ElementRef is provided for `component` this
     * parameter is OverlaySettings. Otherwise it could be ViewContainerRef or OverlayCreateSettings and will be
     * used when dynamic component is created.
     * @param settings (optional): OverlaySettings when `ViewContainerRef` is provided.
     * @returns OverlayInfo
     */
    private getOverlayInfo;
    private placeElementHook;
    private moveElementToOverlay;
    private getWrapperElement;
    private getContentElement;
    private getOverlayElement;
    private updateSize;
    private closeDone;
    private cleanUp;
    private playOpenAnimation;
    private playCloseAnimation;
    private applyAnimationParams;
    private documentClicked;
    private addOutsideClickListener;
    private removeOutsideClickListener;
    private addResizeHandler;
    private removeResizeHandler;
    private addCloseOnEscapeListener;
    private removeCloseOnEscapeListener;
    private addModalClasses;
    private removeModalClasses;
    private buildAnimationPlayers;
    private openAnimationDone;
    private closeAnimationDone;
    private finishAnimations;
    private getComponentSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxOverlayService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxOverlayService>;
}

/**
 * [Documentation](https://www.infragistics.com/products/ignite-ui-angular/angular/components/overlay-scroll).
 * Scroll strategies determines how the scrolling will be handled in the provided IgxOverlayService.
 */
interface IScrollStrategy {
    /**
     * Initializes the strategy. Should be called once
     *
     * @param document reference to Document object.
     * @param overlayService IgxOverlay service to use in this strategy.
     * @param id Unique id for this strategy.
     * ```typescript
     * settings.scrollStrategy.initialize(document, overlay, id);
     * ```
     */
    initialize(document: Document, overlayService: IgxOverlayService, id: string): any;
    /**
     * Attaches the strategy
     * ```typescript
     * settings.scrollStrategy.attach();
     * ```
     */
    attach(): void;
    /**
     * Detaches the strategy
     * ```typescript
     * settings.scrollStrategy.detach();
     * ```
     */
    detach(): void;
}

declare abstract class ScrollStrategy implements IScrollStrategy {
    /**
     * Initializes the strategy. Should be called once
     *
     * @param document reference to Document object.
     * @param overlayService IgxOverlay service to use in this strategy.
     * @param id Unique id for this strategy.
     * ```typescript
     * settings.scrollStrategy.initialize(document, overlay, id);
     * ```
     */
    abstract initialize(document: Document, overlayService: IgxOverlayService, id: string): any;
    /**
     * Attaches the strategy
     * ```typescript
     * settings.scrollStrategy.attach();
     * ```
     */
    abstract attach(): void;
    /**
     * Detaches the strategy
     * ```typescript
     * settings.scrollStrategy.detach();
     * ```
     */
    abstract detach(): void;
}

/**
 * On scroll reposition the overlay content.
 */
declare class AbsoluteScrollStrategy extends ScrollStrategy {
    private _initialized;
    private _document;
    private _overlayService;
    private _id;
    private _scrollContainer;
    private _zone;
    constructor(scrollContainer?: HTMLElement);
    /**
     * Initializes the strategy. Should be called once
     *
     * @param document reference to Document object.
     * @param overlayService IgxOverlay service to use in this strategy.
     * @param id Unique id for this strategy.
     * ```typescript
     * settings.scrollStrategy.initialize(document, overlay, id);
     * ```
     */
    initialize(document: Document, overlayService: IgxOverlayService, id: string): void;
    /**
     * Attaches the strategy
     * ```typescript
     * settings.scrollStrategy.attach();
     * ```
     */
    attach(): void;
    /**
     * Detaches the strategy
     * ```typescript
     * settings.scrollStrategy.detach();
     * ```
     */
    detach(): void;
    private addScrollEventListener;
    private onScroll;
}

/**
 * Prevents scrolling while the overlay content is shown.
 */
declare class BlockScrollStrategy extends ScrollStrategy {
    private _initialized;
    private _document;
    private _initialScrollTop;
    private _initialScrollLeft;
    private _sourceElement;
    constructor();
    /**
     * Initializes the strategy. Should be called once
     *
     */
    initialize(document: Document): void;
    /**
     * Attaches the strategy
     * ```typescript
     * settings.scrollStrategy.attach();
     * ```
     */
    attach(): void;
    /**
     * Detaches the strategy
     * ```typescript
     * settings.scrollStrategy.detach();
     * ```
     */
    detach(): void;
    private onScroll;
}

/**
 * Uses a tolerance and closes the shown component upon scrolling if the tolerance is exceeded
 */
declare class CloseScrollStrategy extends ScrollStrategy {
    private _document;
    private _overlayService;
    private _id;
    private initialScrollTop;
    private initialScrollLeft;
    private _threshold;
    private _initialized;
    private _sourceElement;
    private _scrollContainer;
    private _overlayInfo;
    constructor(scrollContainer?: HTMLElement);
    /**
     * Initializes the strategy. Should be called once
     *
     * @param document reference to Document object.
     * @param overlayService IgxOverlay service to use in this strategy.
     * @param id Unique id for this strategy.
     * ```typescript
     * settings.scrollStrategy.initialize(document, overlay, id);
     * ```
     */
    initialize(document: Document, overlayService: IgxOverlayService, id: string): void;
    /**
     * Attaches the strategy
     * ```typescript
     * settings.scrollStrategy.attach();
     * ```
     */
    attach(): void;
    /**
     * Detaches the strategy
     * ```typescript
     * settings.scrollStrategy.detach();
     * ```
     */
    detach(): void;
    private onScroll;
}

/**
 * Empty scroll strategy. Does nothing.
 */
declare class NoOpScrollStrategy extends ScrollStrategy {
    constructor();
    /**
     * Initializes the strategy. Should be called once
     */
    initialize(): void;
    /**
     * Detaches the strategy
     * ```typescript
     * settings.scrollStrategy.detach();
     * ```
     */
    attach(): void;
    /**
     * Detaches the strategy
     * ```typescript
     * settings.scrollStrategy.detach();
     * ```
     */
    detach(): void;
}

/**
 * Mark an element as an igxOverlay outlet container.
 * Directive instance is exported as `overlay-outlet` to be assigned to templates variables:
 * ```html
 * <div igxOverlayOutlet #outlet="overlay-outlet"></div>
 * ```
 */
declare class IgxOverlayOutletDirective {
    element: ElementRef<HTMLElement>;
    /** @hidden */
    get nativeElement(): HTMLElement;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxOverlayOutletDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxOverlayOutletDirective, "[igxOverlayOutlet]", ["overlay-outlet"], {}, {}, never, never, true, never>;
}
declare enum HorizontalAlignment {
    Left = -1,
    Center = -0.5,
    Right = 0
}
declare enum VerticalAlignment {
    Top = -1,
    Middle = -0.5,
    Bottom = 0
}
/**
 * Defines the possible values of the overlays' position strategy.
 */
declare enum RelativePositionStrategy {
    Connected = "connected",
    Auto = "auto",
    Elastic = "elastic"
}
/**
 * Defines the possible positions for the relative overlay settings presets.
 */
declare enum RelativePosition {
    Above = "above",
    Below = "below",
    Before = "before",
    After = "after",
    Default = "default"
}
/**
 * Defines the possible positions for the absolute overlay settings presets.
 */
declare enum AbsolutePosition {
    Bottom = "bottom",
    Top = "top",
    Center = "center"
}
/**
 * Determines whether to add or set the offset values.
 */
declare enum OffsetMode {
    Add = 0,
    Set = 1
}
declare class Point {
    x: number;
    y: number;
    constructor(x: number, y: number);
}
/** @hidden */
interface OutOfViewPort {
    /** Out of view port at Top or Left */
    back: number;
    /** Out of view port at Bottom or Right */
    forward: number;
}
interface PositionSettings {
    /** Direction in which the component should show */
    horizontalDirection?: HorizontalAlignment;
    /** Direction in which the component should show */
    verticalDirection?: VerticalAlignment;
    /** Target's starting point */
    horizontalStartPoint?: HorizontalAlignment;
    /** Target's starting point */
    verticalStartPoint?: VerticalAlignment;
    /** Animation applied while overlay opens */
    openAnimation?: AnimationReferenceMetadata;
    /** Animation applied while overlay closes */
    closeAnimation?: AnimationReferenceMetadata;
    /** The size up to which element may shrink when shown in elastic position strategy */
    minSize?: Size;
    /** The offset of the element from the target in pixels */
    offset?: number;
}
interface OverlaySettings {
    /** Attaching target for the component to show */
    target?: Point | HTMLElement;
    /** Position strategy to use with these settings */
    positionStrategy?: IPositionStrategy;
    /** Scroll strategy to use with these settings */
    scrollStrategy?: IScrollStrategy;
    /** Set if the overlay should be in modal mode */
    modal?: boolean;
    /** Set if the overlay should close on outside click */
    closeOnOutsideClick?: boolean;
    /** Set if the overlay should close when `Esc` key is pressed */
    closeOnEscape?: boolean;
    /** Set the outlet container to attach the overlay to */
    outlet?: IgxOverlayOutletDirective | ElementRef;
    /**
     * @hidden @internal
     * Elements to be excluded for closeOnOutsideClick.
     * Clicking on the elements in this collection will not close the overlay when closeOnOutsideClick = true.
     */
    excludeFromOutsideClick?: HTMLElement[];
}
interface OverlayEventArgs extends IBaseEventArgs {
    /** Id of the overlay generated with `attach()` method */
    id: string;
    /** Available when `Type<T>` is provided to the `attach()` method and allows access to the created Component instance */
    componentRef?: ComponentRef<any>;
    /** Will provide the elementRef of the markup that will be displayed in the overlay */
    elementRef?: ElementRef<any>;
    /** Will provide the overlay settings which will be used when the component is attached */
    settings?: OverlaySettings;
    /** Will provide the original keyboard event if closed from ESC or click */
    event?: Event;
}
interface OverlayCancelableEventArgs extends OverlayEventArgs, CancelableEventArgs {
}
interface OverlayClosingEventArgs extends OverlayEventArgs, CancelableBrowserEventArgs {
}
interface OverlayAnimationEventArgs extends IBaseEventArgs {
    /** Id of the overlay generated with `attach()` method */
    id: string;
    /** Animation player that will play the animation */
    animationPlayer: AnimationPlayer;
    /** Type of animation to be played. It should be either 'open' or 'close' */
    animationType: 'open' | 'close';
}
interface Size {
    /** Gets or sets the horizontal component of Size */
    width: number;
    /** Gets or sets the vertical component of Size */
    height: number;
}
/** @hidden */
interface OverlayInfo {
    id?: string;
    visible?: boolean;
    detached?: boolean;
    elementRef?: ElementRef;
    componentRef?: ComponentRef<any>;
    settings?: OverlaySettings;
    initialSize?: Size;
    hook?: HTMLElement;
    openAnimationPlayer?: AnimationPlayer;
    openAnimationDetaching?: boolean;
    closeAnimationPlayer?: AnimationPlayer;
    closeAnimationDetaching?: boolean;
    ngZone: NgZone;
    transformX?: number;
    transformY?: number;
    event?: Event;
    wrapperElement?: HTMLElement;
    size?: string;
}
/** @hidden */
interface ConnectedFit {
    contentElementRect?: Partial<DOMRect>;
    targetRect?: Partial<DOMRect>;
    viewPortRect?: Partial<DOMRect>;
    fitHorizontal?: OutOfViewPort;
    fitVertical?: OutOfViewPort;
    left?: number;
    right?: number;
    top?: number;
    bottom?: number;
    horizontalOffset?: number;
    verticalOffset?: number;
}
interface OverlayCreateSettings extends OverlaySettings {
    /**
     * An `Injector` instance to add in the created component ref's injectors tree.
     */
    injector?: Injector;
}
/** @hidden @internal */
declare class Util {
    /**
     * Calculates the rectangle of target for provided overlay settings. Defaults to 0,0,0,0,0,0 rectangle
     * if no target is provided
     *
     * @param settings Overlay settings for which to calculate target rectangle
     */
    static getTargetRect(target?: Point | HTMLElement): Partial<DOMRect>;
    static getViewportRect(document: Document): Partial<DOMRect>;
    static getViewportScrollPosition(document: Document): Point;
    static cloneInstance(object: any): any;
    /**
     * Gets horizontal offset by position settings `offset`.
     */
    static getHorizontalOffset(settings: PositionSettings): number;
    /**
     * Gets vertical offset by position settings `offset`.
     */
    static getVerticalOffset(settings: PositionSettings): number;
}

/** @hidden @internal */
declare abstract class IgxActionStripToken {
    abstract cdr: ChangeDetectorRef;
    abstract context: any;
    abstract menuOverlaySettings: OverlaySettings;
    abstract get hideOnRowLeave(): boolean;
    abstract show(context?: any): void;
    abstract hide(): void;
}
/**
 * Abstract class defining the contract for components that provide actions to the action strip.
 * This allows the action strip to remain standalone and not be aware of specific implementations.
 * @hidden @internal
 */
declare abstract class IgxActionStripActionsToken {
    abstract asMenuItems: boolean;
    abstract buttons: QueryList<any>;
    abstract strip: any | null;
}

/**
 * Templates the default toggle icon in the picker.
 *
 * @remarks Can be applied to IgxDatePickerComponent, IgxTimePickerComponent, IgxDateRangePickerComponent
 *
 * @example
 * ```html
 * <igx-date-range-picker>
 *   <igx-picker-toggle igxSuffix>
 *      <igx-icon>calendar_view_day</igx-icon>
 *   </igx-picker-toggle>
 * </igx-date-range-picker>
 * ```
 */
declare class IgxPickerToggleComponent {
    clicked: EventEmitter<any>;
    onClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPickerToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxPickerToggleComponent, "igx-picker-toggle", never, {}, { "clicked": "clicked"; }, never, ["*"], true, never>;
}
/**
 * Templates the default clear icon in the picker.
 *
 * @remarks Can be applied to IgxDatePickerComponent, IgxTimePickerComponent, IgxDateRangePickerComponent
 *
 * @example
 * ```html
 * <igx-date-picker>
 *   <igx-picker-clear igxSuffix>
 *      <igx-icon>delete</igx-icon>
 *   </igx-picker-clear>
 * </igx-date-picker>
 * ```
 */
declare class IgxPickerClearComponent extends IgxPickerToggleComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPickerClearComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<IgxPickerClearComponent, "igx-picker-clear", never, {}, {}, never, ["*"], true, never>;
}
/**
 * IgxPickerActionsDirective can be used to re-template the dropdown/dialog action buttons.
 *
 * @remarks Can be applied to IgxDatePickerComponent, IgxTimePickerComponent, IgxDateRangePickerComponent
 *
 */
declare class IgxPickerActionsDirective {
    template: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxPickerActionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<IgxPickerActionsDirective, "[igxPickerActions]", never, {}, {}, never, never, true, never>;
}

/** Header orientation in `dialog` mode. */
declare const PickerHeaderOrientation: {
    readonly Horizontal: "horizontal";
    readonly Vertical: "vertical";
};
type PickerHeaderOrientation = (typeof PickerHeaderOrientation)[keyof typeof PickerHeaderOrientation];
/** Calendar orientation. */
declare const PickerCalendarOrientation: {
    readonly Horizontal: "horizontal";
    readonly Vertical: "vertical";
};
type PickerCalendarOrientation = (typeof PickerCalendarOrientation)[keyof typeof PickerCalendarOrientation];
/**
 * This enumeration is used to configure whether the date/time picker has an editable input with drop down
 * or is readonly - the date/time is selected only through a dialog.
 */
declare const PickerInteractionMode: {
    readonly DropDown: "dropdown";
    readonly Dialog: "dialog";
};
type PickerInteractionMode = (typeof PickerInteractionMode)[keyof typeof PickerInteractionMode];
type WeekDays = 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday';
interface IgcCalendarBaseEventMap {
    igcChange: CustomEvent<Date | Date[]>;
}
/** Represents a range between two dates. */
interface DateRange {
    start: Date | string;
    end: Date | string;
}
/** Represents a range between two dates and a label used for predefined and custom date ranges. */
interface CustomDateRange {
    label: string;
    dateRange: DateRange;
}

/**
 * Specify a particular date, time or AmPm part.
 */
declare enum DatePart {
    Date = "date",
    Month = "month",
    Year = "year",
    Hours = "hours",
    Minutes = "minutes",
    Seconds = "seconds",
    FractionalSeconds = "fractionalSeconds",
    AmPm = "ampm",
    Literal = "literal"
}
/** @hidden @internal */
interface DatePartInfo {
    type: DatePart;
    start: number;
    end: number;
    format: string;
}
/** Delta values used for spin actions. */
interface DatePartDeltas {
    date?: number;
    month?: number;
    year?: number;
    hours?: number;
    minutes?: number;
    seconds?: number;
    fractionalSeconds?: number;
}

/**
 * Provides base filtering operations
 * Implementations should be Singleton
 *
 * @export
 */
declare class IgxFilteringOperand {
    protected static _instance: IgxFilteringOperand;
    operations: IFilteringOperation[];
    constructor();
    static instance(): IgxFilteringOperand;
    /**
     * Returns an array of names of the conditions which are visible in the filtering UI
     */
    conditionList(): string[];
    /**
     * Returns an array of names of the conditions which are visible in the UI, including "In" and "Not In", allowing the creation of sub-queries.
     * @hidden @internal
     */
    extendedConditionList(): string[];
    /**
     * Returns an instance of the condition with the specified name.
     *
     * @param name The name of the condition.
     */
    condition(name: string): IFilteringOperation;
    /**
     * Adds a new condition to the filtering operations.
     *
     * @param operation The filtering operation.
     */
    append(operation: IFilteringOperation): void;
    protected findValueInSet(target: any, searchVal: Set<any>): boolean;
}
/**
 * Provides filtering operations for booleans
 *
 * @export
 */
declare class IgxBooleanFilteringOperand extends IgxFilteringOperand {
    protected constructor();
}
/**
 * @internal
 * @hidden
 */
declare class IgxBaseDateTimeFilteringOperand extends IgxFilteringOperand {
    protected constructor();
    /**
     * Splits a Date object into parts
     *
     * @memberof IgxDateFilteringOperand
     */
    static getDateParts(date: Date, dateFormat?: string): IDateParts;
    protected findValueInSet(target: any, searchVal: Set<any>): boolean;
    protected validateInputData(target: Date): void;
}
/**
 * Provides filtering operations for Dates
 *
 * @export
 */
declare class IgxDateFilteringOperand extends IgxBaseDateTimeFilteringOperand {
    protected constructor();
    protected findValueInSet(target: any, searchVal: Set<any>): boolean;
}
declare class IgxDateTimeFilteringOperand extends IgxBaseDateTimeFilteringOperand {
    protected constructor();
}
declare class IgxTimeFilteringOperand extends IgxBaseDateTimeFilteringOperand {
    protected constructor();
    protected findValueInSet(target: any, searchVal: Set<any>): boolean;
}
/**
 * Provides filtering operations for numbers
 *
 * @export
 */
declare class IgxNumberFilteringOperand extends IgxFilteringOperand {
    protected constructor();
}
/**
 * Provides filtering operations for strings
 *
 * @export
 */
declare class IgxStringFilteringOperand extends IgxFilteringOperand {
    protected constructor();
    /**
     * Applies case sensitivity on strings if provided
     *
     * @memberof IgxStringFilteringOperand
     */
    static applyIgnoreCase(a: string, ignoreCase: boolean): string;
}
/**
 * Interface describing filtering operations
 *
 * @export
 */
interface IFilteringOperation {
    name: string;
    isUnary: boolean;
    isNestedQuery?: boolean;
    iconName: string;
    hidden?: boolean;
    logic?: null | ((value: any, searchVal?: any, ignoreCase?: boolean) => boolean);
}
/**
 * Interface describing Date object in parts
 *
 * @export
 */
interface IDateParts {
    year: number;
    month: number;
    day: number;
    hours: number;
    minutes: number;
    seconds: number;
    milliseconds: number;
}

declare enum SortingDirection {
    None = 0,
    Asc = 1,
    Desc = 2
}
interface ISortingExpression<T = any> extends IBaseEventArgs {
    fieldName: KeyOfOrString<T> & string;
    dir: SortingDirection;
    ignoreCase?: boolean;
    strategy?: ISortingStrategy;
}
interface ISortingStrategy {
    sort: (data: any[], fieldName: string, dir: SortingDirection, ignoreCase: boolean, valueResolver: (obj: any, key: string, isDate?: boolean) => any, isDate?: boolean, isTime?: boolean, grid?: GridTypeBase) => any[];
}
declare class DefaultSortingStrategy implements ISortingStrategy {
    protected static _instance: DefaultSortingStrategy;
    protected constructor();
    static instance(): DefaultSortingStrategy;
    sort(data: any[], fieldName: string, dir: SortingDirection, ignoreCase: boolean, valueResolver: (obj: any, key: string, isDate?: boolean) => any, isDate?: boolean, isTime?: boolean): any[];
    compareValues(a: any, b: any): number;
    protected compareObjects(obj1: any, obj2: any, key: string, reverse: number, ignoreCase: boolean, valueResolver: (obj: any, key: string, isDate?: boolean, isTime?: boolean) => any, isDate: boolean, isTime: boolean): number;
    protected arraySort(data: any[], compareFn?: (arg0: any, arg1: any) => number): any[];
    protected prepareSortValue(value: any, ignoreCase: boolean): any;
}
declare class GroupMemberCountSortingStrategy implements ISortingStrategy {
    protected static _instance: GroupMemberCountSortingStrategy;
    protected constructor();
    static instance(): GroupMemberCountSortingStrategy;
    sort(data: any[], fieldName: string, dir: SortingDirection): any[];
    groupBy(data: any, key: any): any;
    protected compareObjects(obj1: any, obj2: any, data: any[], fieldName: string, reverse: number): number;
}
declare class FormattedValuesSortingStrategy extends DefaultSortingStrategy {
    protected static _instance: FormattedValuesSortingStrategy;
    constructor();
    static instance(): FormattedValuesSortingStrategy;
    sort(data: any[], fieldName: string, dir: SortingDirection, ignoreCase: boolean, valueResolver: (obj: any, key: string, isDate?: boolean) => any, isDate?: boolean, isTime?: boolean, grid?: GridTypeBase): any[];
    protected compareObjects(obj1: any, obj2: any, key: string, reverse: number, ignoreCase: boolean, valueResolver: (obj: any, key: string, isDate?: boolean, isTime?: boolean) => any, isDate: boolean, isTime: boolean, grid?: GridTypeBase): number;
}

declare enum FilteringLogic {
    And = 0,
    Or = 1
}
/**
 * Represents filtering expressions.
 */
declare interface IFilteringExpression {
    fieldName: string;
    condition?: IFilteringOperation | null;
    conditionName?: string | null;
    searchVal?: any;
    searchTree?: IExpressionTree | null;
    ignoreCase?: boolean;
}

declare enum FilteringExpressionsTreeType {
    Regular = 0,
    Advanced = 1
}
declare interface IExpressionTree {
    filteringOperands: (IExpressionTree | IFilteringExpression)[];
    operator: FilteringLogic;
    fieldName?: string | null;
    entity?: string | null;
    returnFields?: string[] | null;
}
declare interface IFilteringExpressionsTree extends IBaseEventArgs, IExpressionTree {
    filteringOperands: (IFilteringExpressionsTree | IFilteringExpression)[];
    type?: FilteringExpressionsTreeType;
    /**
     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.find` instead.
     */
    find?: (fieldName: string) => IFilteringExpressionsTree | IFilteringExpression;
    /**
     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.findIndex` instead.
     */
    findIndex?: (fieldName: string) => number;
}
declare class FilteringExpressionsTree implements IFilteringExpressionsTree {
    /**
     * Sets/gets the filtering operands.
     * ```typescript
     * const gridExpressionsTree = new FilteringExpressionsTree(FilteringLogic.And);
     * const expression = [
     * {
     *   condition: IgxStringFilteringOperand.instance().condition('contains'),
     *   fieldName: 'Column Field',
     *   searchVal: 'Value',
     *   ignoreCase: false
     * }];
     * gridExpressionsTree.filteringOperands.push(expression);
     * this.grid.filteringExpressionsTree = gridExpressionsTree;
     * ```
     * ```typescript
     * let filteringOperands = gridExpressionsTree.filteringOperands;
     * ```
     *
     * @memberof FilteringExpressionsTree
     */
    filteringOperands: (IFilteringExpressionsTree | IFilteringExpression)[];
    /**
     * Sets/gets the operator.
     * ```typescript
     * gridExpressionsTree.operator = FilteringLogic.And;
     * ```
     * ```typescript
     * let operator = gridExpressionsTree.operator;
     * ```
     *
     * @memberof FilteringExpressionsTree
     */
    operator: FilteringLogic;
    /**
     * Sets/gets the field name of the column where the filtering expression is placed.
     * ```typescript
     * gridExpressionTree.fieldName = 'Column Field';
     * ```
     * ```typescript
     * let columnField = expressionTree.fieldName;
     * ```
     *
     * @memberof FilteringExpressionsTree
     */
    fieldName?: string;
    /**
     * Sets/gets the type of the filtering expressions tree.
     * ```typescript
     * gridExpressionTree.type = FilteringExpressionsTree.Advanced;
     * ```
     * ```typescript
     * let type = expressionTree.type;
     * ```
     *
     * @memberof FilteringExpressionsTree
     */
    type?: FilteringExpressionsTreeType;
    /**
     * Sets/gets the entity.
     * ```typescript
     * gridExpressionsTree.entity = 'Entity A';
     * ```
     * ```typescript
     * let entity = gridExpressionsTree.entity;
     * ```
     *
     * @memberof FilteringExpressionsTree
     */
    entity?: string;
    /**
     * Sets/gets the return fields.
     * ```typescript
     * gridExpressionsTree.returnFields = ['Column Field 1', 'Column Field 2'];
     * ```
     * ```typescript
     * let returnFields = gridExpressionsTree.returnFields;
     * ```
     *
     * @memberof FilteringExpressionsTree
     */
    returnFields?: string[];
    constructor(operator: FilteringLogic, fieldName?: string, entity?: string, returnFields?: string[]);
    /**
     * Checks if filtering expressions tree is empty.
     *
     * @param expressionTree filtering expressions tree.
     */
    static empty(expressionTree: IFilteringExpressionsTree): boolean;
    /**
     * Returns the filtering expression for a column with the provided fieldName.
     * ```typescript
     * let filteringExpression = gridExpressionTree.find('Column Field');
     * ```
     *
     * @memberof FilteringExpressionsTree
     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.find` instead.
     */
    find(fieldName: string): IFilteringExpressionsTree | IFilteringExpression;
    /**
     * Returns the index of the filtering expression for a column with the provided fieldName.
     * ```typescript
     * let filteringExpressionIndex = gridExpressionTree.findIndex('Column Field');
     * ```
     *
     * @memberof FilteringExpressionsTree
     * @deprecated in version 18.2.0. Use `ExpressionsTreeUtil.findIndex` instead.
     */
    findIndex(fieldName: string): number;
}

/**
 * Minimal type stubs for grid types to avoid circular dependencies.
 * These are simple interfaces that core uses for typing only.
 * The actual implementations are in igniteui-angular/grids.
 */

interface IFieldPipeArgs {
    /** The date/time components that a date column will display, using predefined options or a custom format string. */
    format?: string;
    /** A timezone offset (such as '+0430'), or a standard UTC/GMT or continental US timezone abbreviation. */
    timezone?: string;
    /**
     * Decimal representation options, specified by a string in the following format:
     * `{minIntegerDigits}`.`{minFractionDigits}`-`{maxFractionDigits}`.
     * `minIntegerDigits`: The minimum number of integer digits before the decimal point. Default is 1.
     * `minFractionDigits`: The minimum number of digits after the decimal point. Default is 0.
     * `maxFractionDigits`: The maximum number of digits after the decimal point. Default is 3.
     */
    digitsInfo?: string;
    /** The currency code of type string, default value undefined */
    currencyCode?: string;
    /**
     * Allow us to display currency 'symbol' or 'code' or 'symbol-narrow' or our own string.
     * The value is of type string. By default is set to 'symbol'
     */
    display?: string;
    /** The first week day to be displayed in calendar when filtering or editing a date column */
    weekStart?: WEEKDAYS | number;
}
interface IColumnPipeArgs extends IFieldPipeArgs {
}
interface IFieldEditorOptions {
    /**
     * A custom input format string used for the built-in editors of date/time columns.
     * See the Editing section under https://www.infragistics.com/products/ignite-ui-angular/angular/components/grid/column-types#datetime-date-and-time
     */
    dateTimeFormat?: string;
}
interface IColumnEditorOptions extends IFieldEditorOptions {
}
interface ISortingOptions {
    mode: 'single' | 'multiple';
}
/**
 * @hidden
 * @internal
 */
interface MRLColumnSizeInfo {
    ref: ColumnType;
    width: number;
    colSpan: number;
    colEnd: number;
    widthSetByUser: boolean;
}
/**
 * @hidden
 * @internal
 */
interface MRLResizeColumnInfo {
    target: ColumnType;
    spanUsed: number;
}
/**
 * Enumeration representing the possible positions for pinning columns.
 * - Start: Columns are pinned to the start of the grid.
 * - End: Columns are pinned to the end of the grid.
 */
declare enum ColumnPinningPosition {
    Start = 0,
    End = 1
}
/**
 * Stub type for GridType - minimal interface for typing in core
 */
interface GridTypeBase {
    primaryKey?: string;
    id?: string;
    data: any[] | null;
    [key: string]: any;
}
/**
 * Describes a field that can be used in the Grid and QueryBuilder components.
 */
interface FieldType {
    /**
     * Display label for the field.
     */
    label?: string;
    /**
     * The internal field name, used in expressions and queries.
     */
    field: string;
    /**
     * Optional column header for UI display purposes.
     */
    header?: string;
    /**
     * The data type of the field.
     */
    dataType: GridColumnDataType;
    /**
     * Options for the editor associated with this field.
     */
    editorOptions?: IFieldEditorOptions;
    /**
     * Optional filtering operands that apply to this field.
     */
    filters?: IgxFilteringOperand;
    /**
     * Optional arguments for any pipe applied to the field.
     */
    pipeArgs?: IFieldPipeArgs;
    /**
     * Default time format for Date/Time fields.
     */
    defaultTimeFormat?: string;
    /**
     * Default date/time format for Date/Time fields.
     */
    defaultDateTimeFormat?: string;
    /**
     * Optional formatter function to transform the value before display.
     *
     * @param value - The value of the field.
     * @param rowData - Optional row data that contains this field.
     * @returns The formatted value.
     */
    formatter?(value: any, rowData?: any): any;
}
/**
 * Represents a column in the `GridType`. It is essentially the blueprint to a column object.
 * Contains definitions of properties and methods, relevant to a column
 */
interface ColumnType extends FieldType {
    /** Represents the instance of the parent `GridType` that contains this column. */
    grid: GridTypeBase;
    /**
     * A list containing all the child columns under this column (if any).
     * @deprecated in version 18.1.0. Use the `childColumns` property instead.
     */
    children: QueryList<ColumnType>;
    /**
     * A list containing all the child columns under this column (if any).
     * Empty without children or if this column is not Group or Layout.
     */
    get childColumns(): ColumnType[];
    /** @hidden @internal */
    allChildren: ColumnType[];
    /** @hidden @internal */
    headerGroup: any;
    /** @hidden @internal */
    headerCell: any;
    validators: any[];
    mergingComparer: (prevRecord: any, record: any, field: string) => boolean;
    /**
     * The template reference for the custom header of the column
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    headerTemplate: TemplateRef<any>;
    /**
     * The template reference for the collapsible indicator of the column.
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    collapsibleIndicatorTemplate?: TemplateRef<any>;
    /** Represents custom CSS classes applied to the header element. When added, they take different styling */
    headerClasses: any;
    /** Represents custom CSS styles applied to the header element. When added, they take different styling */
    headerStyles: any;
    /** Represents custom CSS classes applied to the header group. When added, they take different styling */
    headerGroupClasses: any;
    /** Represents custom CSS styles applied to the header group. When added, they take different styling */
    headerGroupStyles: any;
    /**
     * Custom CSS styling, applied to every column
     * calcWidth, minWidthPx, maxWidthPx, minWidth, maxWidth, minWidthPercent, maxWidthPercent, resolvedWidth
     */
    calcWidth: any;
    minWidthPx: number;
    maxWidthPx: number;
    minWidth: string;
    maxWidth: string;
    minWidthPercent: number;
    maxWidthPercent: number;
    resolvedWidth: string;
    /**
     * Optional
     * Represents the header text of the column
     */
    header?: string;
    /**
     * The index of the column within the grid.
     * Includes the hidden columns when counting
     */
    index: number;
    /**
     * Represents the type of data for the column:
     * string, number, boolean, currency, date, time, etc.
     */
    dataType: GridColumnDataType;
    /**
     * Sets properties on the default column editors
     */
    editorOptions: IColumnEditorOptions;
    /**
     * The template reference for the custom inline editor of the column
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    inlineEditorTemplate: TemplateRef<any>;
    /**
     * The index of the column within the grid.
     * Does not include the hidden columns when counting
     */
    visibleIndex: number;
    /** Optional
     * Indicated whether the column can be collapsed. If the value is true, the column can be collapsed
     * It is used in tree grid and for navigation
     */
    collapsible?: boolean;
    /** Indicated whether the column can be edited. If the value is true, the column can be edited */
    editable: boolean;
    /** Specifies whether the column can be resized. If the value is true, the column can be resized */
    resizable: boolean;
    /** Specifies whether the data of the column can be searched. If the value is true, the column data can be searched */
    searchable: boolean;
    /** Specifies whether the column belongs to a group of columns. */
    columnGroup: boolean;
    /** Indicates whether a column can be put in a group. If the value is true, the column can be put in a group */
    groupable: boolean;
    /** Indicates whether a column can be sorted. If the value is true, the column can be sorted. */
    sortable: boolean;
    /** Indicates whether a column can be filtered. If the value is true, the column can be filtered */
    filterable: boolean;
    /** Indicates whether a column is currently hidden (not visible). If the value is true, the column is not visible */
    hidden: boolean;
    /** Indicates whether a column can be pinned. If the value is true, the column cannot be pinned */
    disablePinning: boolean;
    /** Indicates whether a column can be hidden. If the value is true, the column cannot be hidden */
    disableHiding: boolean;
    /**
     * The sorting strategy used for sorting this column.
     * The interface contains a method sort that sorts the provided data based on the given sorting expressions
     */
    sortStrategy: ISortingStrategy;
    /**
    * Indicates whether the search should match results, no matter the case of the letters (upper and lower)
    * If the value is false, the result will depend on the case (example: `E` will not match `e`)
    * If the value is true, the result will not depend on the case (example: `E` will match `e`)
    */
    sortingIgnoreCase: boolean;
    /** @hidden @internal */
    filterCell: any;
    filteringIgnoreCase: boolean;
    /**
     * The filtering expressions for the column.
     * The type contains properties and methods for filtering: filteringOperands, operator (logic), fieldName, etc.
     */
    filteringExpressionsTree: FilteringExpressionsTree;
    hasSummary: boolean;
    summaries: any;
    disabledSummaries?: string[];
    /**
     * The template reference for a summary of the column
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    summaryTemplate: TemplateRef<any>;
    /** Indicates if the column is currently pinned. If the value is true, the column is pinned */
    pinned: boolean;
    /** Indicates if the column is currently expanded or collapsed. If the value is true, the column is expanded */
    expanded: boolean;
    merge: boolean;
    /** Indicates if the column is currently selected. If the value is true, the column is selected */
    selected: boolean;
    /** Indicates if the column can be selected. If the value is true, the column can be selected */
    selectable: boolean;
    columnLayout: boolean;
    /** Represents the hierarchical level of the column in the column layout */
    level: number;
    rowStart: number;
    rowEnd: number;
    colStart: number;
    colEnd: number;
    /** @hidden @internal */
    gridRowSpan: number;
    /** @hidden @internal */
    gridColumnSpan: number;
    columnLayoutChild: boolean;
    width: string;
    /**
     * Optional
     * The root parent of this column (if any).
     * If there is no root parent, that means the current column is the root parent
     */
    topLevelParent?: ColumnType;
    /**
     * Optional
     * The immediate parent (right above) column of this column (if any).
     * If there is no parent, that means the current column is the root parent
     */
    parent: ColumnType | null;
    pipeArgs: IColumnPipeArgs;
    hasNestedPath: boolean;
    additionalTemplateContext: any;
    /** Indicates whether the current column is the last to be pinned.
     * If the value is false, there are columns, that have been pinned after the current */
    isLastPinned: boolean;
    /** Indicates whether the current column is the first for the grid to be pinned.
     * If the value is false, there are columns, that have been pinned before the current */
    isFirstPinned: boolean;
    applySelectableClass: boolean;
    /** The title of the column, used for accessibility purposes */
    title: string;
    /** Represents a method with custom grouping comparator to determine the members of the group. */
    groupingComparer: (a: any, b: any) => number;
    /**
     * Represents a custom template for filtering
     * It is of type TemplateRef, which represents an embedded template, used to instantiate embedded views
     */
    filterCellTemplate: TemplateRef<any>;
    /**
     * A method definition to move the column to the specified index.
     * It takes the index of type number as a parameter
    */
    move(index: number): void;
    /** A method definition to retrieve the set CSS size */
    getAutoSize(): string;
    getResizableColUnderEnd(): MRLResizeColumnInfo[];
    /** A method definition to retrieve the set CSS width of the cells under the column */
    getCellWidth(): string;
    getGridTemplate(isRow: boolean): string;
    /** A method definition to toggle column visibility (hidden or visible) */
    toggleVisibility(value?: boolean): void;
    populateVisibleIndexes?(): void;
    /** Pins the column at the specified index (if not already pinned). */
    pin(index?: number, pinningPosition?: ColumnPinningPosition): boolean;
    /** Unpins the column at the specified index (if not already unpinned). */
    unpin(index?: number): boolean;
}
/**
 * Describes an entity in the QueryBuilder.
 * An entity represents a logical grouping of fields and can have nested child entities.
 */
interface EntityType {
    /**
     * The name of the entity.
     * Typically used as an identifier in expressions.
     */
    name: string;
    /**
     * The list of fields that belong to this entity.
     */
    fields: FieldType[];
    /**
     * Optional child entities.
     * This allows building hierarchical or nested query structures.
     */
    childEntities?: EntityType[];
}
interface ITreeGridRecord {
    key: any;
    data: any;
    children?: ITreeGridRecord[];
    parent?: ITreeGridRecord;
    level?: number;
    isFilteredOutParent?: boolean;
    expanded?: boolean;
}
/**
 * Stub type for IgxTreeGridAPIService - minimal interface for typing in core
 */
interface IgxTreeGridAPIService {
    get_row_id(rowData: any): any;
    [key: string]: any;
}
/** Interface representing a segment of a path in a hierarchical grid. */
interface IPathSegment {
    /**
     * The unique identifier of the row within the segment.
     * @deprecated since version 17.1.0. Use the `rowKey` property instead.
     */
    rowID: any;
    rowKey: any;
    /** The key representing the row's 'hierarchical level. */
    rowIslandKey: string;
}
interface ISummaryExpression {
    fieldName: string;
    customSummary?: any;
}
interface IgxSummaryResult {
    key: string;
    label: string;
    summaryResult: any;
    /**
     * Apply default formatting based on the grid column type.
     * ```typescript
     * const result: IgxSummaryResult = {
     *   key: 'key',
     *   label: 'label',
     *   defaultFormatting: true
     * }
     * ```
     *
     * @memberof IgxSummaryResult
     */
    defaultFormatting?: boolean;
}
interface ISummaryRecord {
    summaries: Map<string, IgxSummaryResult[]>;
    max?: number;
    cellIndentation?: number;
}
/**
 * Enumeration representing different calculation modes for grid summaries.
 * - rootLevelOnly: Summaries are calculated only for the root level.
 * - childLevelsOnly: Summaries are calculated only for child levels.
 * - rootAndChildLevels: Default value; Summaries are calculated for both root and child levels.
 */
declare const GridSummaryCalculationMode: {
    readonly rootLevelOnly: "rootLevelOnly";
    readonly childLevelsOnly: "childLevelsOnly";
    readonly rootAndChildLevels: "rootAndChildLevels";
};
type GridSummaryCalculationMode = (typeof GridSummaryCalculationMode)[keyof typeof GridSummaryCalculationMode];
/**
 * @hidden
 */
declare const GridColumnDataType: {
    readonly String: "string";
    readonly Number: "number";
    readonly Boolean: "boolean";
    readonly Date: "date";
    readonly DateTime: "dateTime";
    readonly Time: "time";
    readonly Currency: "currency";
    readonly Percent: "percent";
    readonly Image: "image";
};
type GridColumnDataType = (typeof GridColumnDataType)[keyof typeof GridColumnDataType];

/** @hidden */
declare const enum AmPmValues {
    AM = "AM",
    A = "a",
    PM = "PM",
    P = "p"
}
/** @hidden */
declare abstract class DateTimeUtil {
    static readonly DEFAULT_INPUT_FORMAT = "MM/dd/yyyy";
    static readonly DEFAULT_TIME_INPUT_FORMAT = "hh:mm tt";
    private static readonly SEPARATOR;
    private static readonly DEFAULT_LOCALE;
    /**
     * Parse a Date value from masked string input based on determined date parts
     *
     * @param inputData masked value to parse
     * @param dateTimeParts Date parts array for the mask
     */
    static parseValueFromMask(inputData: string, dateTimeParts: DatePartInfo[], promptChar?: string): Date | null;
    /** Parse the mask into date/time and literal parts */
    static parseDateTimeFormat(mask: string, locale?: string): DatePartInfo[];
    /** Simplifies the AmPm part to as many chars as will be displayed */
    private static simplifyAmPmFormat;
    static getPartValue(value: Date, datePartInfo: DatePartInfo, partLength: number): string;
    /** Returns the AmPm part value depending on the part length and a
     * conditional expression indicating whether the value is AM or PM.
     */
    static getAmPmValue(partLength: number, isAm: boolean): AmPmValues;
    /** Returns true if a string value indicates an AM period */
    static isAm(value: string): boolean;
    /** Returns true if a string value indicates a PM period */
    static isPm(value: string): boolean;
    /** Builds a date-time editor's default input format based on provided locale settings and data type. */
    static getDefaultInputFormat(locale: string, dataType?: GridColumnDataType): string;
    /** Tries to format a date using Angular's DatePipe. Fallbacks to `Intl` if no locale settings have been loaded. */
    static formatDate(value: number | Date, format: string, locale: string, timezone?: string): string;
    /**
     * Returns the date format based on a provided locale.
     * Supports Angular's DatePipe format options such as `shortDate`, `longDate`.
     */
    static getLocaleDateFormat(locale: string, displayFormat?: string): string;
    /** Determines if a given character is `d/M/y` or `h/m/s`. */
    static isDateOrTimeChar(char: string): boolean;
    /** Spins the date portion in a date-time editor. */
    static spinDate(delta: number, newDate: Date, spinLoop: boolean): void;
    /** Spins the month portion in a date-time editor. */
    static spinMonth(delta: number, newDate: Date, spinLoop: boolean): void;
    /** Spins the year portion in a date-time editor. */
    static spinYear(delta: number, newDate: Date): void;
    /** Spins the hours portion in a date-time editor. */
    static spinHours(delta: number, newDate: Date, spinLoop: boolean): void;
    /** Spins the minutes portion in a date-time editor. */
    static spinMinutes(delta: number, newDate: Date, spinLoop: boolean): void;
    /** Spins the seconds portion in a date-time editor. */
    static spinSeconds(delta: number, newDate: Date, spinLoop: boolean): void;
    /** Spins the fractional seconds (milliseconds) portion in a date-time editor. */
    static spinFractionalSeconds(delta: number, newDate: Date, spinLoop: boolean): void;
    /** Spins the AM/PM portion in a date-time editor. */
    static spinAmPm(newDate: Date, currentDate: Date, amPmFromMask: string): Date;
    /**
     * Determines whether the provided value is greater than the provided max value.
     *
     * @param includeTime set to false if you want to exclude time portion of the two dates
     * @param includeDate set to false if you want to exclude the date portion of the two dates
     * @returns true if provided value is greater than provided maxValue
     */
    static greaterThanMaxValue(value: Date, maxValue: Date, includeTime?: boolean, includeDate?: boolean): boolean;
    /**
     * Determines whether the provided value is less than the provided min value.
     *
     * @param includeTime set to false if you want to exclude time portion of the two dates
     * @param includeDate set to false if you want to exclude the date portion of the two dates
     * @returns true if provided value is less than provided minValue
     */
    static lessThanMinValue(value: Date, minValue: Date, includeTime?: boolean, includeDate?: boolean): boolean;
    /**
     * Validates a value within a given min and max value range.
     *
     * @param value The value to validate
     * @param minValue The lowest possible value that `value` can take
     * @param maxValue The largest possible value that `value` can take
     */
    static validateMinMax(value: Date, minValue: Date | string, maxValue: Date | string, includeTime?: boolean, includeDate?: boolean): ValidationErrors;
    /** Parse an ISO string to a Date */
    static parseIsoDate(value: string): Date | null;
    /**
     * Returns whether the input is valid date
     *
     * @param value input to check
     * @returns true if provided input is a valid date
     */
    static isValidDate(value: any): value is Date;
    static isFormatNumeric(locale: string, inputFormat: string): boolean;
    /**
     * Returns an input format that can be used by the date-time editors, as
     * - if the format is already numeric, return it as is
     * - if it is among the predefined numeric ones, return it as the equivalent locale-based format
     *   for the corresponding numeric date parts
     * - otherwise, return an empty string
     */
    static getNumericInputFormat(locale: string, format: string): string;
    /** Gets the locale-based format from an array of date parts */
    private static getLocaleInputFormatFromParts;
    private static addCurrentPart;
    private static daysInMonth;
    private static trimEmptyPlaceholders;
    private static getMask;
    private static logMissingLocaleSettings;
    private static prependValue;
    private static toTwelveHourFormat;
    private static ensureLeadingZero;
    private static getCleanVal;
    private static determineDatePart;
    private static getFormatOptions;
    private static getDefaultLocaleMask;
    private static getDateStructFromParts;
    private static fillDatePartsPositions;
}

type DayParameter = CalendarDay | Date;
type CalendarRangeParams = {
    start: DayParameter;
    end: DayParameter | number;
    unit?: DayInterval;
    inclusive?: boolean;
};
type CalendarDayParams = {
    year: number;
    month: number;
    date?: number;
};
type DayInterval = "year" | "quarter" | "month" | "week" | "day";
declare const daysInWeek = 7;
declare function toCalendarDay(date: DayParameter): CalendarDay;
declare class CalendarDay {
    private _date;
    /** Constructs and returns the current day. */
    static get today(): CalendarDay;
    /** Constructs a new CalendarDay instance from a Date object. */
    static from(date: Date): CalendarDay;
    constructor(args: CalendarDayParams);
    /** Returns a copy of this instance. */
    clone(): CalendarDay;
    /**
     * Returns a new instance with values replaced.
     */
    set(args: Partial<CalendarDayParams>): CalendarDay;
    add(unit: DayInterval, value: number): CalendarDay;
    /** Returns the day of the week (Sunday = 0). */
    get day(): number;
    /** Returns the full year. */
    get year(): number;
    /** Returns the month. */
    get month(): number;
    /** Returns the date */
    get date(): number;
    /** Returns the timestamp since epoch in milliseconds. */
    get timestamp(): number;
    /** Returns the ISO 8601 week number. */
    get week(): number;
    /**
     * Gets the week number based on week start day.
     * Uses ISO 8601 (first Thursday rule) only when weekStart is Monday (1).
     * For other week starts, uses simple counting from January 1st.
     */
    getWeekNumber(weekStart?: number): number;
    /**
     * Calculates week number using ISO 8601 standard (Monday start, first Thursday rule).
     */
    private calculateISO8601WeekNumber;
    /**
     * Calculates week number using simple counting from January 1st.
     */
    private calculateSimpleWeekNumber;
    /**
     * Gets the Thursday of the current date's week (ISO 8601 helper).
     */
    private getThursdayOfWeek;
    /**
     * Gets the Thursday of the first week of the given year (ISO 8601 helper).
     */
    private getFirstWeekThursday;
    /**
     * Calculates the number of weeks between two Thursday dates (ISO 8601 helper).
     */
    private getWeeksDifference;
    /**
     * Gets the last week number of the previous year (ISO 8601 helper).
     */
    private getPreviousYearLastWeek;
    /** Returns the underlying native date instance. */
    get native(): Date;
    /**
     * Whether the current date is a weekend day.
     *
     * @remarks
     * This is naive, since it does not account for locale specifics.
     */
    get weekend(): boolean;
    equalTo(value: DayParameter): boolean;
    greaterThan(value: DayParameter): boolean;
    greaterThanOrEqual(value: DayParameter): boolean;
    lessThan(value: DayParameter): boolean;
    lessThanOrEqual(value: DayParameter): boolean;
    toString(): string;
}

declare function areSameMonth(firstMonth: DayParameter, secondMonth: DayParameter): boolean;
declare function isNextMonth(target: DayParameter, origin: DayParameter): boolean;
declare function isPreviousMonth(target: DayParameter, origin: DayParameter): boolean;
/** Returns the next date starting from `start` that does not match the `disabled` descriptors */
declare function getNextActiveDate(start: CalendarDay, disabled?: DateRangeDescriptor[]): CalendarDay;
/** Returns the previous date starting from `start` that does not match the `disabled` descriptors */
declare function getPreviousActiveDate(start: CalendarDay, disabled?: DateRangeDescriptor[]): CalendarDay;
declare function getClosestActiveDate(start: CalendarDay, delta: number, disabled?: DateRangeDescriptor[]): CalendarDay;
/**
 * Returns a generator yielding day values between `start` and `end` (non-inclusive)
 * by a given `unit` as a step.
 *
 * @remarks
 * By default, `unit` is set to 'day'.
 */
declare function calendarRange(options: CalendarRangeParams): Generator<CalendarDay, void, unknown>;
declare function generateMonth(value: DayParameter, firstWeekDay: number): Generator<CalendarDay, void, unknown>;
declare function getYearRange(current: DayParameter, range: number): {
    start: number;
    end: number;
};
declare function isDateInRanges(date: DayParameter, ranges: DateRangeDescriptor[]): boolean;
declare function formatToParts(date: Date, locale: string, options: Intl.DateTimeFormatOptions, parts: string[]): Record<string, any>;

interface IDataCloneStrategy {
    /**
     * Clones provided data
     * @param data primitive value, date and object to be cloned
     * @returns deep copy of provided value
     */
    clone(data: any): any;
}
/**
 * Simplified data clone strategy that deep clones primitive values, dates and objects.
 * Does not support circular references in objects.
 */
declare class DefaultDataCloneStrategy implements IDataCloneStrategy {
    clone(data: any): any;
}
/**
 * Data clone strategy that is uses cache to deep clone primitive values, dates and objects.
 * It allows using circular references inside object.
 */
declare class CachedDataCloneStrategy implements IDataCloneStrategy {
    clone(data: any): any;
}

declare class FilterUtil {
    static filter<T>(data: T[], state: IFilteringState, grid?: GridTypeBase): T[];
}
interface IFilteringStrategy {
    filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridTypeBase): any[];
    getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree): Promise<IgxFilterItem[]>;
}
interface IgxFilterItem {
    value: any;
    label?: string;
    children?: IgxFilterItem[];
}
declare abstract class BaseFilteringStrategy implements IFilteringStrategy {
    findMatchByExpression(rec: any, expr: IFilteringExpression, isDate?: boolean, isTime?: boolean, grid?: GridTypeBase): boolean;
    matchRecord(rec: any, expressions: IFilteringExpressionsTree | IFilteringExpression, grid?: GridTypeBase, entity?: string): boolean;
    private findEntityByName;
    getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree): Promise<IgxFilterItem[]>;
    protected getFilteredData(column: ColumnType, tree: IFilteringExpressionsTree): any;
    protected getFilterItemLabel(column: ColumnType, value: any, applyFormatter: boolean, data: any): any;
    protected getFilterItemKeyValue(value: any, column: ColumnType): {
        key: any;
        finalValue: any;
    };
    protected shouldFormatFilterValues(_column: ColumnType): boolean;
    abstract filter(data: any[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridTypeBase): any[];
    protected abstract getFieldValue(rec: any, fieldName: string, isDate?: boolean, isTime?: boolean, grid?: GridTypeBase): any;
}
declare class NoopFilteringStrategy extends BaseFilteringStrategy {
    protected getFieldValue(rec: any, _fieldName: string): any;
    private static _instance;
    static instance(): NoopFilteringStrategy;
    filter(data: any[], _: IFilteringExpressionsTree, __?: IFilteringExpressionsTree): any[];
}
declare class FilteringStrategy extends BaseFilteringStrategy {
    private static _instance;
    static instance(): FilteringStrategy;
    filter<T>(data: T[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree: IFilteringExpressionsTree, grid: GridTypeBase): T[];
    protected getFieldValue(rec: any, fieldName: string, isDate?: boolean, isTime?: boolean, grid?: GridTypeBase): any;
}
declare class FormattedValuesFilteringStrategy extends FilteringStrategy {
    private fields?;
    /**
     * Creates a new instance of FormattedValuesFilteringStrategy.
     *
     * @param fields An array of column field names that should be formatted.
     * If omitted the values of all columns which has formatter will be formatted.
     */
    constructor(fields?: string[]);
    protected shouldFormatFilterValues(column: ColumnType): boolean;
}

declare interface IFilteringState {
    expressionsTree: IFilteringExpressionsTree;
    advancedExpressionsTree?: IFilteringExpressionsTree;
    strategy?: IFilteringStrategy;
}

declare class TreeGridFilteringStrategy extends BaseFilteringStrategy {
    hierarchicalFilterFields?: string[];
    constructor(hierarchicalFilterFields?: string[]);
    filter(data: ITreeGridRecord[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridTypeBase): ITreeGridRecord[];
    protected getFieldValue(rec: any, fieldName: string, isDate?: boolean, isTime?: boolean, grid?: GridTypeBase): any;
    private getHierarchicalFieldValue;
    private filterImpl;
    private isHierarchicalFilterField;
    getFilterItems(column: ColumnType, tree: IFilteringExpressionsTree): Promise<IgxFilterItem[]>;
    protected getFilteredData(column: ColumnType, tree: IFilteringExpressionsTree): any;
    private getHierarchicalFilterItems;
}
declare class TreeGridFormattedValuesFilteringStrategy extends TreeGridFilteringStrategy {
    private fields?;
    /**
     * Creates a new instance of FormattedValuesFilteringStrategy.
     *
     * @param fields An array of column field names that should be formatted.
     * If omitted the values of all columns which has formatter will be formatted.
     */
    constructor(fields?: string[]);
    protected shouldFormatFilterValues(column: ColumnType): boolean;
}
declare class TreeGridMatchingRecordsOnlyFilteringStrategy extends TreeGridFilteringStrategy {
    filter(data: ITreeGridRecord[], expressionsTree: IFilteringExpressionsTree, advancedExpressionsTree?: IFilteringExpressionsTree, grid?: GridTypeBase): ITreeGridRecord[];
    private filterImplementation;
    private setCorrectLevelToFilteredRecords;
}

interface IMergeByResult {
    rowSpan: number;
    root?: any;
    childRecords?: any[];
}
/**
 * Merge strategy interface.
 */
interface IGridMergeStrategy {
    /**
     * Function that processes merging of the whole data per merged field.
     * Returns collection where object has reference to the original record and map of the cell merge metadata per field.
     */
    merge: (data: any[], field: string, comparer: (prevRecord: any, currentRecord: any, field: string) => boolean, result: any[], activeRowIndexes: number[], isDate?: boolean, isTime?: boolean, grid?: GridTypeBase) => any[];
    /**
     * Function that compares values for merging. Returns true if same, false if different.
     */
    comparer: (prevRecord: any, record: any, field: string) => boolean;
}
declare class DefaultMergeStrategy implements IGridMergeStrategy {
    protected static _instance: DefaultMergeStrategy;
    static instance(): DefaultMergeStrategy;
    merge(data: any[], field: string, comparer: (prevRecord: any, record: any, field: string, isDate?: boolean, isTime?: boolean) => boolean, result: any[], activeRowIndexes: number[], isDate?: boolean, isTime?: boolean, grid?: GridTypeBase): any[];
    comparer(prevRecord: any, record: any, field: string, isDate?: boolean, isTime?: boolean): boolean;
    /**
     * Retrieves the value of the specified field from the given object, considering date and time data types.
     * `key`: The key of the field to retrieve.
     * `isDate`: (Optional) Indicates if the field is of type Date.
     * `isTime`: (Optional) Indicates if the field is of type Time.
     * Returns the value of the specified field in the data object.
     * @internal
     */
    protected getFieldValue<T>(obj: T, key: string, isDate?: boolean, isTime?: boolean): unknown;
    /**
   * @internal
   */
    protected getDateValue<T>(obj: T, isDate?: boolean, isTime?: boolean): any;
}
declare class DefaultTreeGridMergeStrategy extends DefaultMergeStrategy {
    comparer(prevRecord: any, record: any, field: string, isDate?: boolean, isTime?: boolean): boolean;
}
declare class ByLevelTreeGridMergeStrategy extends DefaultMergeStrategy {
    comparer(prevRecord: any, record: any, field: string, isDate?: boolean, isTime?: boolean): boolean;
}

declare class ExpressionsTreeUtil {
    /**
     * Returns the filtering expression for a column with the provided tree and fieldName.
     * ```typescript
     * let filteringExpression = ExpressionsTreeUtil.find(gridExpressionTree, 'Column Field');
     * ```
     */
    static find(tree: IFilteringExpressionsTree, fieldName: string): IFilteringExpressionsTree | IFilteringExpression;
    /**
     * Returns the index of the filtering expression for a column with the provided tree and fieldName.
     * ```typescript
     * let filteringExpressionIndex = ExpressionsTreeUtil.findIndex(gridExpressionTree, 'Column Field');
     * ```
     */
    static findIndex(tree: IFilteringExpressionsTree, fieldName: string): number;
    protected static isFilteringExpressionsTreeForColumn(expressionsTree: IFilteringExpressionsTree, fieldName: string): boolean;
}
/**
 * Checks if the given entry is an IExpressionTree.
 * @param entry The entry to check.
 * @returns True if the entry is an IExpressionTree, false otherwise.
 */
declare function isTree(entry: IExpressionTree | IFilteringExpression): entry is IExpressionTree;
/**
 * Recreates the tree from a given array of entities by applying the correct operands
 * for each expression and adjusting the search values to be the correct type.
 * @param tree The expression tree to recreate.
 * @param entities An array of entities to use for recreating the tree.
 * @returns The recreated expression tree.
 */
declare function recreateTree(tree: IExpressionTree, entities: EntityType[], isRoot?: boolean): IExpressionTree;
/**
 * Recreates the tree from a given array of fields by applying the correct operands.
 * It is recommended to use `recreateTree` if there will be multiple entities in the tree
 * with potentially colliding field names.
 * @param tree The expression tree to recreate.
 * @param fields An array of fields to use for recreating the tree.
 */
declare function recreateTreeFromFields(tree: IExpressionTree, fields: FieldType[]): IExpressionTree;

interface IGroupByExpandState {
    expanded: boolean;
    hierarchy: Array<IGroupByKey>;
}
interface IGroupByKey {
    fieldName: string;
    value: any;
}

/**
 * @hidden
 */
declare class GroupedRecords extends Array<any> {
}
interface IGroupByRecord {
    expression: ISortingExpression;
    level: number;
    records: GroupedRecords;
    value: any;
    groupParent: IGroupByRecord;
    groups?: IGroupByRecord[];
    height: number;
    column?: ColumnType;
}

interface IGroupingExpression extends ISortingExpression {
    groupingComparer?: (a: any, b: any, currRec?: any, groupRec?: any) => number;
}

interface IGroupingState {
    expressions: IGroupingExpression[];
    expansion: IGroupByExpandState[];
    defaultExpanded: boolean;
}

interface IGroupByResult {
    data: any[];
    metadata: IGroupByRecord[];
}

/**
 * Represents a sorting strategy for the grid data
 * Contains a single method sort that sorts the provided data based on the given sorting expressions
 */
interface IGridSortingStrategy {
    /**
    * `data`: The array of data to be sorted. Could be of any type.
    * `expressions`: An array of sorting expressions that define the sorting rules. The expression contains information like file name, whether the letter case should be taken into account, etc.
    * `grid`: (Optional) The instance of the grid where the sorting is applied.
    * Returns a new array with the data sorted according to the sorting expressions.
    */
    sort(data: any[], expressions: ISortingExpression[], grid?: GridTypeBase): any[];
}
/**
 * Represents a grouping strategy for the grid data, extending the Sorting Strategy interface (contains a sorting method).
 */
interface IGridGroupingStrategy extends IGridSortingStrategy {
    /**
     * The method groups the provided data based on the given grouping state and returns the result.
     * `data`: The array of data to be grouped. Could be of any type.
     * `state`: The grouping state that defines the grouping settings and expressions.
     * `grid`: (Optional) The instance of the grid where the grouping is applied.
     * `groupsRecords`: (Optional) An array that holds the records for each group.
     * `fullResult`: (Optional) The complete result of grouping including groups and summary data.
     * Returns an object containing the result of the grouping operation.
     */
    groupBy(data: any[], state: IGroupingState, grid?: any, groupsRecords?: any[], fullResult?: IGroupByResult): IGroupByResult;
}
/**
 * Represents a class implementing the IGridSortingStrategy interface.
 * It provides sorting functionality for grid data based on sorting expressions.
 */
declare class IgxSorting implements IGridSortingStrategy {
    /**
   * Sorts the provided data based on the given sorting expressions.
   * `data`: The array of data to be sorted.
   * `expressions`: An array of sorting expressions that define the sorting rules. The expression contains information like file name, whether the letter case should be taken into account, etc.
   * `grid`: (Optional) The instance of the grid where the sorting is applied.
   * Returns a new array with the data sorted according to the sorting expressions.
   */
    sort(data: any[], expressions: ISortingExpression[], grid?: GridTypeBase): any[];
    /**
     * Retrieves the value of the specified field from the given object, considering date and time data types.
     * `key`: The key of the field to retrieve.
     * `isDate`: (Optional) Indicates if the field is of type Date.
     * `isTime`: (Optional) Indicates if the field is of type Time.
     * Returns the value of the specified field in the data object.
     * @internal
     */
    protected getFieldValue<T>(obj: T, key: string, isDate?: boolean, isTime?: boolean): unknown;
    /**
   * Sorts the provided data array based on the given sorting expressions.
   * The method can be used when multiple sorting is performed, going through each one
   * Returns a new array with the data sorted according to the sorting expressions.
   * @internal
   */
    private sortData;
    private prepareExpressions;
}
/**
 * Represents a class implementing the IGridGroupingStrategy interface and extending the IgxSorting class.
 * It provides a method to group data based on the given grouping state.
 */
declare class IgxGrouping extends IgxSorting implements IGridGroupingStrategy {
    /**
     * Groups the provided data based on the given grouping state.
     * Returns an object containing the result of the grouping operation.
     */
    groupBy(data: any[], state: IGroupingState, grid?: any, groupsRecords?: any[], fullResult?: IGroupByResult): IGroupByResult;
    /**
     * Groups the provided data based on the given grouping state.
     * Changes groupsRecords and fullResult collections by reference.
     * Returns an array containing the visible grouped result.
     * @internal
     */
    protected groupData(data: any[], state: IGroupingState, grid: GridTypeBase, groupsRecords: any[], fullResult: IGroupByResult): IGroupByResult;
    /**
     * Groups the records in the provided data array based on the given grouping expression.
     * `groupingComparer`: (Optional) A custom grouping comparator to determine the members of the group.
     * Returns an array containing the records that belong to the group.
     * @internal
     */
    private groupedRecordsByExpression;
}
/**
 * Represents a class implementing the IGridSortingStrategy interface with a no-operation sorting strategy.
 * It performs no sorting and returns the data as it is.
 */
declare class NoopSortingStrategy implements IGridSortingStrategy {
    private static _instance;
    private constructor();
    static instance(): NoopSortingStrategy;
    sort(data: any[]): any[];
}
/**
 * Represents a class extending the IgxSorting class
 * Provides custom data record sorting.
 */
declare class IgxDataRecordSorting extends IgxSorting {
    /**
    * Overrides the base method to retrieve the field value from the data object instead of the record object.
    * Returns the value of the specified field in the data object.
    */
    protected getFieldValue(obj: any, key: string, isDate?: boolean, isTime?: boolean): any;
}

declare enum PagingError {
    None = 0,
    IncorrectPageIndex = 1,
    IncorrectRecordsPerPage = 2
}
declare interface IPagingState {
    index: number;
    recordsPerPage: number;
    metadata?: {
        countPages: number;
        error: PagingError;
        countRecords: number;
    };
}

declare enum TransactionType {
    ADD = "add",
    DELETE = "delete",
    UPDATE = "update"
}
declare enum TransactionEventOrigin {
    UNDO = "undo",
    REDO = "redo",
    CLEAR = "clear",
    ADD = "add",
    END = "endPending"
}
interface Transaction {
    id: any;
    type: TransactionType;
    newValue: any;
}
/**
 * @experimental
 * @hidden
 */
interface HierarchicalTransaction extends Transaction {
    path?: any[];
}
interface State {
    value: any;
    recordRef: any;
    type: TransactionType;
}
interface Action<T extends Transaction> {
    transaction: T;
    recordRef: any;
}
interface StateUpdateEvent {
    origin: TransactionEventOrigin;
    actions: Action<Transaction>[];
}
/**
 * @experimental
 * @hidden
 */
interface HierarchicalState extends State {
    path: any[];
}
interface TransactionService<T extends Transaction, S extends State> {
    /**
     * Returns whether transaction is enabled for this service
     */
    readonly enabled: boolean;
    /**
     * Gets/Sets the data clone strategy used to clone data
     */
    cloneStrategy: IDataCloneStrategy;
    /**
     * Event fired when transaction state has changed - add transaction, commit all transactions, undo and redo
     */
    onStateUpdate?: EventEmitter<StateUpdateEvent>;
    /**
     * @returns if there are any transactions in the Undo stack
     */
    canUndo: boolean;
    /**
     * @returns if there are any transactions in the Redo stack
     */
    canRedo: boolean;
    /**
     * Adds provided  transaction with recordRef if any
     *
     * @param transaction Transaction to be added
     * @param recordRef Reference to the value of the record in the data source related to the changed item
     */
    add(transaction: T, recordRef?: any): void;
    /**
     * Returns all recorded transactions in chronological order
     *
     * @param id Optional record id to get transactions for
     * @returns All transaction in the service or for the specified record
     */
    getTransactionLog(id?: any): T[];
    /**
     * Remove the last transaction if any
     */
    undo(): void;
    /**
     * Applies the last undone transaction if any
     */
    redo(): void;
    /**
     * Returns aggregated changes from all transactions
     *
     * @param mergeChanges If set to true will merge each state's value over relate recordRef
     * and will record resulting value in the related transaction
     * @returns Collection of aggregated transactions for each changed record
     */
    getAggregatedChanges(mergeChanges: boolean): T[];
    /**
     * Returns the state of the record with provided id
     *
     * @param id The id of the record
     * @param pending Should get pending state
     * @returns State of the record if any
     */
    getState(id: any, pending?: boolean): S;
    /**
     * Returns value of the required id including all uncommitted changes
     *
     * @param id The id of the record to return value for
     * @param mergeChanges If set to true will merge state's value over relate recordRef
     * and will return merged value
     * @returns Value with changes or **null**
     */
    getAggregatedValue(id: any, mergeChanges: boolean): any;
    /**
     * Applies all transactions over the provided data
     *
     * @param data Data source to update
     * @param id Optional record id to commit transactions for
     */
    commit(data: any[], id?: any): void;
    /**
     * Clears all transactions
     *
     * @param id Optional record id to clear transactions for
     */
    clear(id?: any): void;
    /**
     * Starts pending transactions. All transactions passed after call to startPending
     * will not be added to transaction log
     */
    startPending(): void;
    /**
     * Clears all pending transactions and aggregated pending state. If commit is set to true
     * commits pending states as single transaction
     *
     * @param commit Should commit the pending states
     */
    endPending(commit: boolean): void;
}

/**
 * @hidden
 */
declare class DataUtil {
    static sort<T>(data: T[], expressions: ISortingExpression[], sorting?: IGridSortingStrategy, grid?: GridTypeBase): T[];
    static treeGridSort(hierarchicalData: ITreeGridRecord[], expressions: ISortingExpression[], sorting?: IGridSortingStrategy, grid?: GridTypeBase): ITreeGridRecord[];
    static cloneTreeGridRecord(hierarchicalRecord: ITreeGridRecord): ITreeGridRecord;
    static group<T>(data: T[], state: IGroupingState, grouping?: IGridGroupingStrategy, grid?: GridTypeBase, groupsRecords?: any[], fullResult?: IGroupByResult): IGroupByResult;
    static merge<T>(data: T[], columns: ColumnType[], strategy?: IGridMergeStrategy, activeRowIndexes?: any[], grid?: GridTypeBase): any[];
    static page<T>(data: T[], state: IPagingState, dataLength?: number): T[];
    static correctPagingState(state: IPagingState, length: number): void;
    static getHierarchy(gRow: IGroupByRecord): Array<IGroupByKey>;
    static isHierarchyMatch(h1: Array<IGroupByKey>, h2: Array<IGroupByKey>, expressions: IGroupingExpression[]): boolean;
    /**
     * Merges all changes from provided transactions into provided data collection
     *
     * @param data Collection to merge
     * @param transactions Transactions to merge into data
     * @param primaryKey Primary key of the collection, if any
     * @param deleteRows Should delete rows with DELETE transaction type from data
     * @returns Provided data collections updated with all provided transactions
     */
    static mergeTransactions<T>(data: T[], transactions: Transaction[], primaryKey?: any, cloneStrategy?: IDataCloneStrategy, deleteRows?: boolean): T[];
    /**
     * Merges all changes from provided transactions into provided hierarchical data collection
     *
     * @param data Collection to merge
     * @param transactions Transactions to merge into data
     * @param childDataKey Data key of child collections
     * @param primaryKey Primary key of the collection, if any
     * @param deleteRows Should delete rows with DELETE transaction type from data
     * @returns Provided data collections updated with all provided transactions
     */
    static mergeHierarchicalTransactions(data: any[], transactions: HierarchicalTransaction[], childDataKey: any, primaryKey?: any, cloneStrategy?: IDataCloneStrategy, deleteRows?: boolean): any[];
    static parseValue(dataType: GridColumnDataType, value: any): any;
    static filterDataByExpressions(data: any[], expressionsTree: IFilteringExpressionsTree, grid: GridTypeBase): any;
    private static findParentFromPath;
}

declare const isHierarchyMatch: (h1: Array<IGroupByKey>, h2: Array<IGroupByKey>, expressions: IGroupingExpression[]) => boolean;
declare const getHierarchy: (gRow: IGroupByRecord) => Array<IGroupByKey>;

declare class IgxAngularAnimationPlayer implements AnimationPlayer {
    private internalPlayer;
    private _innerPlayer;
    animationStart: EventEmitter<IBaseEventArgs>;
    animationEnd: EventEmitter<IBaseEventArgs>;
    get position(): number;
    set position(value: number);
    constructor(internalPlayer: AnimationPlayer$1);
    init(): void;
    play(): void;
    finish(): void;
    reset(): void;
    destroy(): void;
    hasStarted(): boolean;
    private onDone;
}

declare class IgxAngularAnimationService implements AnimationService {
    private builder;
    buildAnimation(animationMetaData: AnimationReferenceMetadata, element: HTMLElement): AnimationPlayer;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxAngularAnimationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxAngularAnimationService>;
}

/**
 * @hidden @internal
 */
type Direction = 'ltr' | 'rtl';
/**
 * Injection token is used to inject the document into Directionality
 * which factory could be faked for testing purposes.
 *
 * We can't provide and mock the DOCUMENT token from platform-browser because configureTestingModule
 * allows override of the default providers, directive, pipes, modules of the test injector
 * which causes errors.
 *
 * @hidden @internal
 */
declare const DIR_DOCUMENT: InjectionToken<Document>;
/**
 * @hidden @internal
 *
 * Bidirectional service that extracts the value of the direction attribute on the body or html elements.
 *
 * The dir attribute over the body element takes precedence.
 */
declare class IgxDirectionality {
    private _dir;
    private _document;
    get value(): Direction;
    get document(): Document;
    get rtl(): boolean;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxDirectionality, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxDirectionality>;
}

/**
 * Positions the element based on the directions and start point passed in trough PositionSettings.
 * It is possible to either pass a start point or an HTMLElement as a positioning base.
 */
declare class ConnectedPositioningStrategy implements IPositionStrategy {
    /**
     * PositionSettings to use when position the component in the overlay
     */
    settings: PositionSettings;
    private _defaultSettings;
    constructor(settings?: PositionSettings);
    /**
     * Position the element based on the PositionStrategy implementing this interface.
     *
     * @param contentElement The HTML element to be positioned
     * @param size Size of the element
     * @param document reference to the Document object
     * @param initialCall should be true if this is the initial call to the method
     * @param target attaching target for the component to show
     * ```typescript
     * settings.positionStrategy.position(content, size, document, true);
     * ```
     */
    position(contentElement: HTMLElement, size: Size, document?: Document, initialCall?: boolean, target?: Point | HTMLElement): void;
    /**
     * Creates clone of this position strategy
     * @returns clone of this position strategy
     */
    clone(): IPositionStrategy;
    /**
     * Obtains the DomRect objects for the required elements - target and element to position
     *
     * @returns target and element DomRect objects
     */
    protected calculateElementRectangles(contentElement: any, target: Point | HTMLElement): {
        targetRect: Partial<DOMRect>;
        elementRect: Partial<DOMRect>;
    };
    /**
     * Get element horizontal and vertical offsets by connectedFit
     * or `this.settings` if connectedFit offset is not defined.
     *
     * @param connectedFit
     * @returns horizontalOffset and verticalOffset
     */
    protected getElementOffsets(connectedFit: ConnectedFit): {
        horizontalOffset: number;
        verticalOffset: number;
    };
    /**
     * Sets element's style which effectively positions provided element according
     * to provided position settings
     *
     * @param element Element to position
     * @param targetRect Bounding rectangle of strategy target
     * @param elementRect Bounding rectangle of the element
     */
    protected setStyle(element: HTMLElement, targetRect: Partial<DOMRect>, elementRect: Partial<DOMRect>, connectedFit: ConnectedFit): void;
}

declare abstract class BaseFitPositionStrategy extends ConnectedPositioningStrategy {
    protected _initialSize: Size;
    protected _initialSettings: PositionSettings;
    /**
     * Position the element based on the PositionStrategy implementing this interface.
     *
     * @param contentElement The HTML element to be positioned
     * @param size Size of the element
     * @param document reference to the Document object
     * @param initialCall should be true if this is the initial call to the method
     * @param target attaching target for the component to show
     * ```typescript
     * settings.positionStrategy.position(content, size, document, true);
     * ```
     */
    position(contentElement: HTMLElement, size: Size, document?: Document, initialCall?: boolean, target?: Point | HTMLElement): void;
    /**
     * Checks if element can fit in viewport and updates provided connectedFit
     * with the result
     *
     * @param connectedFit connectedFit to update
     */
    protected updateViewPortFit(connectedFit: ConnectedFit): void;
    /**
     * Calculates the position of the left border of the element if it gets positioned
     * with provided start point and direction
     *
     * @param targetRect Rectangle of the target where element is attached
     * @param elementRect Rectangle of the element
     * @param startPoint Start point of the target
     * @param direction Direction in which to show the element
     */
    protected calculateLeft(targetRect: Partial<DOMRect>, elementRect: Partial<DOMRect>, startPoint: HorizontalAlignment, direction: HorizontalAlignment, offset?: number): number;
    /**
     * Calculates the position of the top border of the element if it gets positioned
     * with provided position settings related to the target
     *
     * @param targetRect Rectangle of the target where element is attached
     * @param elementRect Rectangle of the element
     * @param startPoint Start point of the target
     * @param direction Direction in which to show the element
     */
    protected calculateTop(targetRect: Partial<DOMRect>, elementRect: Partial<DOMRect>, startPoint: VerticalAlignment, direction: VerticalAlignment, offset?: number): number;
    /**
     * Returns whether the element should fit in viewport
     *
     * @param connectedFit connectedFit object containing all necessary parameters
     */
    protected shouldFitInViewPort(connectedFit: ConnectedFit): boolean;
    /**
     * Fits the element into viewport according to the position settings
     *
     * @param element element to fit in viewport
     * @param connectedFit connectedFit object containing all necessary parameters
     */
    protected abstract fitInViewport(element: HTMLElement, connectedFit: ConnectedFit): any;
}

/**
 * Positions the element based on the directions passed in trough PositionSettings.
 * These are Top/Middle/Bottom for verticalDirection and Left/Center/Right for horizontalDirection
 */
declare class GlobalPositionStrategy implements IPositionStrategy {
    /**
     * PositionSettings to use when position the component in the overlay
     */
    settings: PositionSettings;
    protected _defaultSettings: PositionSettings;
    constructor(settings?: PositionSettings);
    /**
     * Position the element based on the PositionStrategy implementing this interface.
     *
     * @param contentElement The HTML element to be positioned
     * @param size Size of the element
     * @param document reference to the Document object
     * @param initialCall should be true if this is the initial call to the method
     * @param target attaching target for the component to show
     * ```typescript
     * settings.positionStrategy.position(content, size, document, true);
     * ```
     */
    position(contentElement: HTMLElement): void;
    /**
     * Clone the strategy instance.
     * ```typescript
     * settings.positionStrategy.clone();
     * ```
     */
    clone(): IPositionStrategy;
    protected setPosition(contentElement: HTMLElement): void;
}

/**
 * Positions the element inside the containing outlet based on the directions passed in trough PositionSettings.
 * These are Top/Middle/Bottom for verticalDirection and Left/Center/Right for horizontalDirection
 */
declare class ContainerPositionStrategy extends GlobalPositionStrategy {
    constructor(settings?: PositionSettings);
    /**
     * Position the element based on the PositionStrategy implementing this interface.
     */
    position(contentElement: HTMLElement): void;
}

/**
 * Positions the element as in **Connected** positioning strategy and re-positions the element in
 * the view port (calculating a different start point) in case the element is partially getting out of view
 */
declare class AutoPositionStrategy extends BaseFitPositionStrategy {
    /**
     * Fits the element into viewport according to the position settings
     *
     * @param element element to fit in viewport
     * @param connectedFit connectedFit object containing all necessary parameters
     */
    protected fitInViewport(element: HTMLElement, connectedFit: ConnectedFit): void;
    /**
     * Checks if element can be flipped without get off the viewport
     *
     * @param connectedFit connectedFit object containing all necessary parameters
     * @returns true if element can be flipped and stain in viewport
     */
    private canFlipHorizontal;
    /**
     * Checks if element can be flipped without get off the viewport
     *
     * @param connectedFit connectedFit object containing all necessary parameters
     * @returns true if element can be flipped and stain in viewport
     */
    private canFlipVertical;
    /**
     * Flips direction and start point of the position settings
     */
    private flipHorizontal;
    /**
     * Flips direction and start point of the position settings
     */
    private flipVertical;
    /**
     * Calculates necessary horizontal push according to provided connectedFit
     *
     * @param connectedFit connectedFit object containing all necessary parameters
     * @returns amount of necessary translation which will push the element into viewport
     */
    private horizontalPush;
    /**
     * Calculates necessary vertical push according to provided connectedFit
     *
     * @param connectedFit connectedFit object containing all necessary parameters
     * @returns amount of necessary translation which will push the element into viewport
     */
    private verticalPush;
    /**
     * Changes open and close animation with reverse animation if one exists
     *
     * @param flipDirection direction for which to change the animations
     */
    private flipAnimation;
    /**
     * Tries to find the reverse animation according to provided direction
     *
     * @param animation animation to update
     * @param direction required animation direction
     * @returns reverse animation in given direction if one exists
     */
    private updateAnimation;
}

/**
 * Positions the element as in **Connected** positioning strategy and resize the element
 * to fit in the view port in case the element is partially getting out of view
 */
declare class ElasticPositionStrategy extends BaseFitPositionStrategy {
    /**
     * Fits the element into viewport according to the position settings
     *
     * @param element element to fit in viewport
     * @param connectedFit connectedFit object containing all necessary parameters
     */
    protected fitInViewport(element: HTMLElement, connectedFit: ConnectedFit): void;
}

declare class IgxBaseTransactionService<T extends Transaction, S extends State> implements TransactionService<T, S> {
    /**
     * Gets/Sets the data clone strategy used to clone data
     */
    get cloneStrategy(): IDataCloneStrategy;
    set cloneStrategy(strategy: IDataCloneStrategy);
    /**
     * @returns if there are any transactions in the Redo stack
     */
    get canRedo(): boolean;
    /**
     * @returns if there are any transactions in the Undo stack
     */
    get canUndo(): boolean;
    /**
     * Returns whether transaction is enabled for this service
     */
    get enabled(): boolean;
    /**
     * Event fired when transaction state has changed - add transaction, commit all transactions, undo and redo
     */
    onStateUpdate: EventEmitter<StateUpdateEvent>;
    protected _isPending: boolean;
    protected _pendingTransactions: T[];
    protected _pendingStates: Map<any, S>;
    private _cloneStrategy;
    /**
     * Adds provided  transaction with recordRef if any
     *
     * @param transaction Transaction to be added
     * @param recordRef Reference to the value of the record in the data source related to the changed item
     */
    add(transaction: T, recordRef?: any): void;
    /**
     * Returns all recorded transactions in chronological order
     *
     * @param id Optional record id to get transactions for
     * @returns All transaction in the service or for the specified record
     */
    getTransactionLog(_id?: any): T[];
    /**
     * Remove the last transaction if any
     */
    undo(): void;
    /**
     * Applies the last undone transaction if any
     */
    redo(): void;
    /**
     * Returns aggregated changes from all transactions
     *
     * @param mergeChanges If set to true will merge each state's value over relate recordRef
     * and will record resulting value in the related transaction
     * @returns Collection of aggregated transactions for each changed record
     */
    getAggregatedChanges(mergeChanges: boolean): T[];
    /**
     * Returns the state of the record with provided id
     *
     * @param id The id of the record
     * @param pending Should get pending state
     * @returns State of the record if any
     */
    getState(id: any): S;
    /**
     * Returns value of the required id including all uncommitted changes
     *
     * @param id The id of the record to return value for
     * @param mergeChanges If set to true will merge state's value over relate recordRef
     * and will return merged value
     * @returns Value with changes or **null**
     */
    getAggregatedValue(id: any, mergeChanges: boolean): any;
    /**
     * Applies all transactions over the provided data
     *
     * @param data Data source to update
     * @param id Optional record id to commit transactions for
     */
    commit(_data: any[], _id?: any): void;
    /**
     * Clears all transactions
     *
     * @param id Optional record id to clear transactions for
     */
    clear(_id?: any): void;
    /**
     * Starts pending transactions. All transactions passed after call to startPending
     * will not be added to transaction log
     */
    startPending(): void;
    /**
     * Clears all pending transactions and aggregated pending state. If commit is set to true
     * commits pending states as single transaction
     *
     * @param commit Should commit the pending states
     */
    endPending(_commit: boolean): void;
    /**
     * Updates the provided states collection according to passed transaction and recordRef
     *
     * @param states States collection to apply the update to
     * @param transaction Transaction to apply to the current state
     * @param recordRef Reference to the value of the record in data source, if any, where transaction should be applied
     */
    protected updateState(states: Map<any, S>, transaction: T, recordRef?: any): void;
    /**
     * Updates the recordRef of the provided state with all the changes in the state. Accepts primitive and object value types
     *
     * @param state State to update value for
     * @returns updated value including all the changes in provided state
     */
    protected updateValue(state: S): any;
    /**
     * Merges second values in first value and the result in empty object. If values are primitive type
     * returns second value if exists, or first value.
     *
     * @param first Value to merge into
     * @param second Value to merge
     */
    protected mergeValues<U>(first: U, second: U): U;
    /**
     * Compares the state with recordRef and clears all duplicated values. If any state ends as
     * empty object removes it from states.
     *
     * @param state State to clean
     */
    protected cleanState(id: any, states: Map<any, S>): void;
}

interface HierarchicalTransactionService<T extends HierarchicalTransaction, S extends HierarchicalState> extends TransactionService<T, S> {
    /**
     * Applies all transactions over the provided data
     *
     * @param data Data source to update
     * @param id Optional record id to commit transactions for
     */
    commit(data: any[], id?: any): void;
    /**
     * Applies all transactions over the provided data
     *
     * @param data Data source to update
     * @param primaryKey Primary key of the hierarchical data
     * @param childDataKey Key of child data collection
     * @param id Optional record id to commit transactions for
     */
    commit(data: any[], primaryKey: any, childDataKey: any, id?: any): void;
}

declare class IgxTransactionService<T extends Transaction, S extends State> extends IgxBaseTransactionService<T, S> {
    protected _transactions: T[];
    protected _redoStack: Action<T>[][];
    protected _undoStack: Action<T>[][];
    protected _states: Map<any, S>;
    /**
     * @returns if there are any transactions in the Undo stack
     */
    get canUndo(): boolean;
    /**
     * @returns if there are any transactions in the Redo stack
     */
    get canRedo(): boolean;
    /**
     * Adds provided  transaction with recordRef if any
     *
     * @param transaction Transaction to be added
     * @param recordRef Reference to the value of the record in the data source related to the changed item
     */
    add(transaction: T, recordRef?: any): void;
    /**
     * Returns all recorded transactions in chronological order
     *
     * @param id Optional record id to get transactions for
     * @returns All transaction in the service or for the specified record
     */
    getTransactionLog(id?: any): T[];
    /**
     * Returns aggregated changes from all transactions
     *
     * @param mergeChanges If set to true will merge each state's value over relate recordRef
     * and will record resulting value in the related transaction
     * @returns Collection of aggregated transactions for each changed record
     */
    getAggregatedChanges(mergeChanges: boolean): T[];
    /**
     * Returns the state of the record with provided id
     *
     * @param id The id of the record
     * @param pending Should get pending state
     * @returns State of the record if any
     */
    getState(id: any, pending?: boolean): S;
    /**
     * Returns whether transaction is enabled for this service
     */
    get enabled(): boolean;
    /**
     * Returns value of the required id including all uncommitted changes
     *
     * @param id The id of the record to return value for
     * @param mergeChanges If set to true will merge state's value over relate recordRef
     * and will return merged value
     * @returns Value with changes or **null**
     */
    getAggregatedValue(id: any, mergeChanges: boolean): any;
    /**
     * Clears all pending transactions and aggregated pending state. If commit is set to true
     * commits pending states as single transaction
     *
     * @param commit Should commit the pending states
     */
    endPending(commit: boolean): void;
    /**
     * Applies all transactions over the provided data
     *
     * @param data Data source to update
     * @param id Optional record id to commit transactions for
     */
    commit(data: any[], id?: any): void;
    /**
     * Clears all transactions
     *
     * @param id Optional record id to clear transactions for
     */
    clear(id?: any): void;
    /**
     * Remove the last transaction if any
     */
    undo(): void;
    /**
     * Applies the last undone transaction if any
     */
    redo(): void;
    protected addTransaction(transaction: T, states: Map<any, S>, recordRef?: any): void;
    /**
     * Verifies if the passed transaction is correct. If not throws an exception.
     *
     * @param transaction Transaction to be verified
     */
    protected verifyAddedTransaction(states: Map<any, S>, transaction: T, recordRef?: any): void;
    /**
     * Updates the provided states collection according to passed transaction and recordRef
     *
     * @param states States collection to apply the update to
     * @param transaction Transaction to apply to the current state
     * @param recordRef Reference to the value of the record in data source, if any, where transaction should be applied
     */
    protected updateState(states: Map<any, S>, transaction: T, recordRef?: any): void;
    /**
     * Updates state related record in the provided data
     *
     * @param data Data source to update
     * @param state State to update data from
     */
    protected updateRecord(data: any[], state: S): void;
}

/** @experimental @hidden */
declare class IgxHierarchicalTransactionService<T extends HierarchicalTransaction, S extends HierarchicalState> extends IgxTransactionService<T, S> implements HierarchicalTransactionService<T, S> {
    getAggregatedChanges(mergeChanges: boolean): T[];
    commit(data: any[], primaryKeyOrId?: any, childDataKey?: any, id?: any): void;
    protected updateState(states: Map<any, S>, transaction: T, recordRef?: any): void;
    private clearArraysFromObject;
}

/**
 * The type of the transaction that should be provided.
 * When batchEditing is disabled, `None` is provided.
 * When enabled - `Base` is provided.
 * An enum instead of a boolean value leaves room for extra scenarios in the future.
 */
declare const enum TRANSACTION_TYPE {
    'None' = "None",
    'Base' = "Base"
}
/**
 * Factory service for instantiating TransactionServices
 */
declare class IgxFlatTransactionFactory {
    /**
     * Creates a new Transaction service instance depending on the specified type.
     *
     * @param type The type of the transaction
     * @returns a new instance of TransactionService<Transaction, State>
     */
    create(type: TRANSACTION_TYPE): TransactionService<Transaction, State>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxFlatTransactionFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxFlatTransactionFactory>;
}
/**
 * Factory service for instantiating HierarchicalTransactionServices
 */
declare class IgxHierarchicalTransactionFactory extends IgxFlatTransactionFactory {
    /**
     * Creates a new HierarchialTransaction service instance depending on the specified type.
     *
     * @param type The type of the transaction
     * @returns a new instance of HierarchialTransaction<HierarchialTransaction, HierarchialState>
     */
    create(type: TRANSACTION_TYPE): HierarchicalTransactionService<HierarchicalTransaction, HierarchicalState>;
    static ɵfac: i0.ɵɵFactoryDeclaration<IgxHierarchicalTransactionFactory, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IgxHierarchicalTransactionFactory>;
}

interface igcPerformance {
    startMeasure: typeof startMeasure;
    getMeasures: typeof getMeasures;
    clearMeasures: typeof clearMeasures;
    clearAll: typeof clearAll;
}
declare global {
    var $$igcPerformance: igcPerformance;
}
declare function startMeasure(name: string, withLogging?: boolean): () => void;
declare function getMeasures(name?: string): PerformanceEntryList;
declare function clearMeasures(name?: string, withLogging?: boolean): void;
declare function clearAll(withLogging?: boolean): void;
declare class PerformanceService {
    private readonly _ngZone;
    private _logEnabled;
    constructor();
    setLogEnabled(state: boolean): void;
    start(name: string): () => void;
    getMeasures(name?: string): PerformanceEntryList;
    clearMeasures(name?: string): void;
    clearAll(): void;
    attachObserver(options?: PerformanceObserverInit): () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PerformanceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PerformanceService>;
}

interface IActionStripResourceStrings {
    igx_action_strip_button_more_title?: string;
}
declare const ActionStripResourceStringsEN: IActionStripResourceStrings;

interface IBannerResourceStrings {
    igx_banner_button_dismiss?: string;
}
declare const BannerResourceStringsEN: IBannerResourceStrings;

interface ICalendarResourceStrings {
    igx_calendar_previous_month?: string;
    igx_calendar_next_month?: string;
    igx_calendar_previous_year?: string;
    igx_calendar_next_year?: string;
    igx_calendar_previous_years?: string;
    igx_calendar_next_years?: string;
    igx_calendar_select_date?: string;
    igx_calendar_select_month?: string;
    igx_calendar_select_year?: string;
    igx_calendar_range_start?: string;
    igx_calendar_range_end?: string;
    igx_calendar_range_label_start?: string;
    igx_calendar_range_label_end?: string;
    igx_calendar_range_placeholder?: string;
    igx_calendar_selected_month_is?: string;
    igx_calendar_first_picker_of?: string;
    igx_calendar_multi_selection?: string;
    igx_calendar_range_selection?: string;
    igx_calendar_single_selection?: string;
    igx_calendar_singular_multi_selection?: string;
    igx_calendar_singular_range_selection?: string;
    igx_calendar_singular_single_selection?: string;
}
declare const CalendarResourceStringsEN: ICalendarResourceStrings;

interface ICarouselResourceStrings {
    igx_carousel_of?: string;
    igx_carousel_slide?: string;
    igx_carousel_previous_slide?: string;
    igx_carousel_next_slide?: string;
}
declare const CarouselResourceStringsEN: ICarouselResourceStrings;

interface IChipResourceStrings {
    igx_chip_remove?: string;
    igx_chip_select?: string;
}
declare const ChipResourceStringsEN: IChipResourceStrings;

interface IComboResourceStrings {
    igx_combo_empty_message?: string;
    igx_combo_filter_search_placeholder?: string;
    igx_combo_addCustomValues_placeholder?: string;
    igx_combo_clearItems_placeholder?: string;
    igx_combo_aria_label_options?: string;
    igx_combo_aria_label_no_options?: string;
}
declare const ComboResourceStringsEN: IComboResourceStrings;

interface IDatePickerResourceStrings {
    igx_date_picker_change_date?: string;
    igx_date_picker_choose_date?: string;
}
declare const DatePickerResourceStringsEN: IDatePickerResourceStrings;

interface IDateRangePickerResourceStrings {
    igx_date_range_picker_date_separator?: string;
    igx_date_range_picker_done_button?: string;
    igx_date_range_picker_cancel_button?: string;
    igx_date_range_picker_last7Days?: string;
    igx_date_range_picker_currentMonth?: string;
    igx_date_range_picker_last30Days?: string;
    igx_date_range_picker_yearToDate?: string;
}
declare const DateRangePickerResourceStringsEN: IDateRangePickerResourceStrings;

interface IGridResourceStrings {
    igx_grid_groupByArea_message?: string;
    igx_grid_groupByArea_select_message?: string;
    igx_grid_groupByArea_deselect_message?: string;
    igx_grid_emptyFilteredGrid_message?: string;
    igx_grid_emptyGrid_message?: string;
    igx_grid_filter?: string;
    igx_grid_filter_row_close?: string;
    igx_grid_filter_row_reset?: string;
    igx_grid_filter_row_placeholder?: string;
    igx_grid_filter_row_boolean_placeholder?: string;
    igx_grid_filter_row_date_placeholder?: string;
    igx_grid_filter_row_time_placeholder?: string;
    igx_grid_filter_operator_and?: string;
    igx_grid_complex_filter?: string;
    igx_grid_filter_operator_or?: string;
    igx_grid_filter_contains?: string;
    igx_grid_filter_doesNotContain?: string;
    igx_grid_filter_startsWith?: string;
    igx_grid_filter_endsWith?: string;
    igx_grid_filter_equals?: string;
    igx_grid_filter_doesNotEqual?: string;
    igx_grid_filter_empty?: string;
    igx_grid_filter_notEmpty?: string;
    igx_grid_filter_null?: string;
    igx_grid_filter_notNull?: string;
    igx_grid_filter_before?: string;
    igx_grid_filter_after?: string;
    igx_grid_filter_at?: string;
    igx_grid_filter_not_at?: string;
    igx_grid_filter_at_before?: string;
    igx_grid_filter_at_after?: string;
    igx_grid_filter_today?: string;
    igx_grid_filter_yesterday?: string;
    igx_grid_filter_thisMonth?: string;
    igx_grid_filter_lastMonth?: string;
    igx_grid_filter_nextMonth?: string;
    igx_grid_filter_thisYear?: string;
    igx_grid_filter_lastYear?: string;
    igx_grid_filter_nextYear?: string;
    igx_grid_filter_greaterThan?: string;
    igx_grid_filter_lessThan?: string;
    igx_grid_filter_greaterThanOrEqualTo?: string;
    igx_grid_filter_lessThanOrEqualTo?: string;
    igx_grid_filter_true?: string;
    igx_grid_filter_false?: string;
    igx_grid_filter_all?: string;
    igx_grid_filter_in?: string;
    igx_grid_filter_notIn?: string;
    igx_grid_filter_condition_placeholder?: string;
    igx_grid_summary_count?: string;
    igx_grid_summary_min?: string;
    igx_grid_summary_max?: string;
    igx_grid_summary_sum?: string;
    igx_grid_summary_average?: string;
    igx_grid_summary_earliest?: string;
    igx_grid_summary_latest?: string;
    igx_grid_excel_filter_moving_left?: string;
    igx_grid_excel_filter_moving_left_short?: string;
    igx_grid_excel_filter_moving_right?: string;
    igx_grid_excel_filter_moving_right_short?: string;
    igx_grid_excel_filter_moving_header?: string;
    igx_grid_excel_filter_sorting_asc?: string;
    igx_grid_excel_filter_sorting_asc_short?: string;
    igx_grid_excel_filter_sorting_desc?: string;
    igx_grid_excel_filter_sorting_desc_short?: string;
    igx_grid_excel_filter_sorting_header?: string;
    igx_grid_excel_filter_clear?: string;
    igx_grid_excel_custom_dialog_add?: string;
    igx_grid_excel_custom_dialog_clear?: string;
    igx_grid_excel_custom_dialog_header?: string;
    igx_grid_excel_cancel?: string;
    igx_grid_excel_apply?: string;
    igx_grid_excel_search_placeholder?: string;
    igx_grid_excel_select_all?: string;
    igx_grid_excel_select_all_search_results?: string;
    igx_grid_excel_add_to_filter?: string;
    igx_grid_excel_blanks?: string;
    igx_grid_excel_hide?: string;
    igx_grid_excel_show?: string;
    igx_grid_excel_pin?: string;
    igx_grid_excel_unpin?: string;
    igx_grid_excel_select?: string;
    igx_grid_excel_deselect?: string;
    igx_grid_excel_text_filter?: string;
    igx_grid_excel_number_filter?: string;
    igx_grid_excel_date_filter?: string;
    igx_grid_excel_boolean_filter?: string;
    igx_grid_excel_currency_filter?: string;
    igx_grid_excel_custom_filter?: string;
    igx_grid_excel_no_matches?: string;
    igx_grid_excel_matches_count?: string;
    igx_grid_advanced_filter_title?: string;
    igx_grid_advanced_filter_from_label?: string;
    igx_grid_advanced_filter_and_group?: string;
    igx_grid_advanced_filter_or_group?: string;
    igx_grid_advanced_filter_end_group?: string;
    igx_grid_advanced_filter_create_and_group?: string;
    igx_grid_advanced_filter_create_or_group?: string;
    igx_grid_advanced_filter_and_label?: string;
    igx_grid_advanced_filter_or_label?: string;
    igx_grid_advanced_filter_add_condition?: string;
    igx_grid_advanced_filter_add_condition_root?: string;
    igx_grid_advanced_filter_add_group?: string;
    igx_grid_advanced_filter_add_group_root?: string;
    igx_grid_advanced_filter_ungroup?: string;
    igx_grid_advanced_filter_delete?: string;
    igx_grid_advanced_filter_delete_filters?: string;
    igx_grid_advanced_filter_initial_text?: string;
    igx_grid_advanced_filter_column_placeholder?: string;
    igx_grid_advanced_filter_value_placeholder?: string;
    igx_grid_advanced_filter_query_value_placeholder?: string;
    igx_grid_advanced_filter_switch_group?: string;
    igx_grid_advanced_filter_dialog_title?: string;
    igx_grid_advanced_filter_dialog_message?: string;
    igx_grid_advanced_filter_dialog_checkbox_text?: string;
    igx_grid_advanced_filter_drop_ghost_text?: string;
    igx_grid_advanced_filter_select_entity?: string;
    igx_grid_advanced_filter_select_return_field_single?: string;
    igx_grid_pinned_row_indicator?: string;
    igx_grid_hiding_check_all_label?: string;
    igx_grid_hiding_uncheck_all_label?: string;
    igx_grid_pinning_check_all_label?: string;
    igx_grid_pinning_uncheck_all_label?: string;
    igx_grid_row_edit_btn_done?: string;
    igx_grid_row_edit_btn_cancel?: string;
    igx_grid_row_edit_text?: string;
    igx_grid_toolbar_actions_filter_prompt?: string;
    igx_grid_toolbar_pinning_button_tooltip?: string;
    igx_grid_toolbar_hiding_button_tooltip?: string;
    igx_grid_toolbar_pinning_title?: string;
    igx_grid_toolbar_hiding_title?: string;
    igx_grid_toolbar_advanced_filtering_button_tooltip?: string;
    igx_grid_toolbar_advanced_filtering_button_label?: string;
    igx_grid_toolbar_exporter_button_tooltip?: string;
    igx_grid_toolbar_exporter_button_label?: string;
    igx_grid_toolbar_exporter_excel_entry_text?: string;
    igx_grid_toolbar_exporter_csv_entry_text?: string;
    igx_grid_toolbar_exporter_pdf_entry_text?: string;
    igx_grid_snackbar_addrow_label?: string;
    igx_grid_snackbar_addrow_actiontext?: string;
    igx_grid_actions_edit_label?: string;
    igx_grid_actions_add_label?: string;
    igx_grid_add_row_label?: string;
    igx_grid_actions_add_child_label?: string;
    igx_grid_actions_delete_label?: string;
    igx_grid_actions_pin_label?: string;
    igx_grid_actions_unpin_label?: string;
    igx_grid_actions_jumpUp_label?: string;
    igx_grid_actions_jumpDown_label?: string;
    igx_grid_pivot_date_dimension_total?: string;
    igx_grid_pivot_aggregate_count?: string;
    igx_grid_pivot_aggregate_min?: string;
    igx_grid_pivot_aggregate_max?: string;
    igx_grid_pivot_aggregate_sum?: string;
    igx_grid_pivot_aggregate_avg?: string;
    igx_grid_pivot_aggregate_date_latest?: string;
    igx_grid_pivot_aggregate_date_earliest?: string;
    igx_grid_pivot_aggregate_time_latest?: string;
    igx_grid_pivot_aggregate_time_earliest?: string;
    igx_grid_pivot_empty_row_drop_area?: string;
    igx_grid_pivot_empty_column_drop_area?: string;
    igx_grid_pivot_empty_filter_drop_area?: string;
    igx_grid_pivot_empty_value_drop_area?: string;
    igx_grid_pivot_row_drop_chip?: string;
    igx_grid_pivot_column_drop_chip?: string;
    igx_grid_pivot_filter_drop_chip?: string;
    igx_grid_pivot_value_drop_chip?: string;
    igx_grid_pivot_empty_message?: string;
    igx_grid_pivot_selector_filters?: string;
    igx_grid_pivot_selector_rows?: string;
    igx_grid_pivot_selector_columns?: string;
    igx_grid_pivot_selector_values?: string;
    igx_grid_pivot_selector_panel_empty?: string;
    igx_grid_required_validation_error?: string;
    igx_grid_min_validation_error?: string;
    igx_grid_max_validation_error?: string;
    igx_grid_min_length_validation_error?: string;
    igx_grid_max_length_validation_error?: string;
    igx_grid_email_validation_error?: string;
    igx_grid_pattern_validation_error?: string;
}
declare const GridResourceStringsEN: IGridResourceStrings;

interface IInputResourceStrings {
    igx_input_upload_button?: string;
    igx_input_file_placeholder?: string;
}
declare const InputResourceStringsEN: IInputResourceStrings;

interface IListResourceStrings {
    igx_list_no_items?: string;
    igx_list_loading?: string;
}
declare const ListResourceStringsEN: IListResourceStrings;

interface IPaginatorResourceStrings {
    igx_paginator_label?: string;
    igx_paginator_pager_text?: string;
    igx_paginator_first_page_button_text?: string;
    igx_paginator_previous_page_button_text?: string;
    igx_paginator_last_page_button_text?: string;
    igx_paginator_next_page_button_text?: string;
}
declare const PaginatorResourceStringsEN: IPaginatorResourceStrings;

interface IQueryBuilderResourceStrings {
    igx_query_builder_date_placeholder?: string;
    igx_query_builder_time_placeholder?: string;
    igx_query_builder_datetime_placeholder?: string;
    igx_query_builder_filter_operator_and?: string;
    igx_query_builder_filter_operator_or?: string;
    igx_query_builder_filter_contains?: string;
    igx_query_builder_filter_doesNotContain?: string;
    igx_query_builder_filter_startsWith?: string;
    igx_query_builder_filter_endsWith?: string;
    igx_query_builder_filter_equals?: string;
    igx_query_builder_filter_doesNotEqual?: string;
    igx_query_builder_filter_empty?: string;
    igx_query_builder_filter_notEmpty?: string;
    igx_query_builder_filter_null?: string;
    igx_query_builder_filter_notNull?: string;
    igx_query_builder_filter_in?: string;
    igx_query_builder_filter_notIn?: string;
    igx_query_builder_filter_before?: string;
    igx_query_builder_filter_after?: string;
    igx_query_builder_filter_at?: string;
    igx_query_builder_filter_not_at?: string;
    igx_query_builder_filter_at_before?: string;
    igx_query_builder_filter_at_after?: string;
    igx_query_builder_filter_today?: string;
    igx_query_builder_filter_yesterday?: string;
    igx_query_builder_filter_thisMonth?: string;
    igx_query_builder_filter_lastMonth?: string;
    igx_query_builder_filter_nextMonth?: string;
    igx_query_builder_filter_thisYear?: string;
    igx_query_builder_filter_lastYear?: string;
    igx_query_builder_filter_nextYear?: string;
    igx_query_builder_filter_greaterThan?: string;
    igx_query_builder_filter_lessThan?: string;
    igx_query_builder_filter_greaterThanOrEqualTo?: string;
    igx_query_builder_filter_lessThanOrEqualTo?: string;
    igx_query_builder_filter_true?: string;
    igx_query_builder_filter_false?: string;
    igx_query_builder_filter_all?: string;
    igx_query_builder_from_label?: string;
    igx_query_builder_select_label?: string;
    igx_query_builder_where_label?: string;
    igx_query_builder_and_group?: string;
    igx_query_builder_or_group?: string;
    igx_query_builder_end_group?: string;
    igx_query_builder_and_label?: string;
    igx_query_builder_or_label?: string;
    igx_query_builder_switch_group?: string;
    igx_query_builder_add_condition?: string;
    igx_query_builder_add_group?: string;
    igx_query_builder_add_condition_root?: string;
    igx_query_builder_add_group_root?: string;
    igx_query_builder_ungroup?: string;
    igx_query_builder_delete?: string;
    igx_query_builder_delete_filters?: string;
    igx_query_builder_initial_text?: string;
    igx_query_builder_column_placeholder?: string;
    igx_query_builder_condition_placeholder?: string;
    igx_query_builder_value_placeholder?: string;
    igx_query_builder_query_value_placeholder?: string;
    igx_query_builder_all_fields?: string;
    igx_query_builder_details?: string;
    igx_query_builder_search?: string;
    igx_query_builder_select_all?: string;
    igx_query_builder_select_entity?: string;
    igx_query_builder_select_return_field_single?: string;
    igx_query_builder_select_return_fields?: string;
    igx_query_builder_dialog_title?: string;
    igx_query_builder_dialog_message?: string;
    igx_query_builder_dialog_checkbox_text?: string;
    igx_query_builder_dialog_cancel?: string;
    igx_query_builder_dialog_confirm?: string;
    igx_query_builder_drop_ghost_text?: string;
}
declare const QueryBuilderResourceStringsEN: IQueryBuilderResourceStrings;

interface ITimePickerResourceStrings {
    igx_time_picker_ok?: string;
    igx_time_picker_cancel?: string;
    igx_time_picker_change_time?: string;
    igx_time_picker_choose_time?: string;
}
declare const TimePickerResourceStringsEN: ITimePickerResourceStrings;

interface ITreeResourceStrings {
    igx_expand?: string;
    igx_collapse?: string;
}
declare const TreeResourceStringsEN: ITreeResourceStrings;

interface IResourceStrings extends IGridResourceStrings, ITimePickerResourceStrings, ICalendarResourceStrings, ICarouselResourceStrings, IChipResourceStrings, IComboResourceStrings, IInputResourceStrings, IDatePickerResourceStrings, IDateRangePickerResourceStrings, IListResourceStrings, IPaginatorResourceStrings, ITreeResourceStrings, IActionStripResourceStrings, IQueryBuilderResourceStrings, IBannerResourceStrings {
}
declare class igxI18N {
    private static _instance;
    private _currentResourceStrings;
    private constructor();
    static instance(): igxI18N;
    /**
     * Changes the resource strings for all components in the application
     * ```
     * @param resourceStrings to be applied
     */
    changei18n(resourceStrings: IResourceStrings): void;
    getCurrentResourceStrings(en: IResourceStrings): IResourceStrings;
}
declare function getCurrentResourceStrings(en: IResourceStrings): IResourceStrings;
declare function changei18n(resourceStrings: IResourceStrings): void;

/**
 * Global type augmentations for IgniteUI Angular
 */
declare global {
    interface GlobalEventHandlersEventMap {
        'keydown.enter': KeyboardEvent;
        'keydown.escape': KeyboardEvent;
        'keydown.tab': KeyboardEvent;
        'keydown.arrowup': KeyboardEvent;
        'keydown.arrowdown': KeyboardEvent;
        'keydown.arrowleft': KeyboardEvent;
        'keydown.arrowright': KeyboardEvent;
        'keydown.shift.tab': KeyboardEvent;
        'keydown.alt.arrowup': KeyboardEvent;
        'keydown.alt.arrowdown': KeyboardEvent;
        'keydown.pageup': KeyboardEvent;
        'keydown.pagedown': KeyboardEvent;
        'keydown.home': KeyboardEvent;
        'keydown.end': KeyboardEvent;
        'keydown.space': KeyboardEvent;
        'igcChange': CustomEvent;
    }
}

export { ACCORDION_NAVIGATION_KEYS, AbsolutePosition, AbsoluteScrollStrategy, ActionStripResourceStringsEN, AutoPositionStrategy, BannerResourceStringsEN, BaseFilteringStrategy, BaseFitPositionStrategy, BlockScrollStrategy, ByLevelTreeGridMergeStrategy, CachedDataCloneStrategy, CalendarDay, CalendarResourceStringsEN, CarouselResourceStringsEN, ChipResourceStringsEN, CloseScrollStrategy, ColumnPinningPosition, ComboResourceStringsEN, ConnectedPositioningStrategy, ContainerPositionStrategy, DataUtil, DatePart, DatePickerResourceStringsEN, DateRangePickerResourceStringsEN, DateRangeType, DateTimeUtil, DefaultDataCloneStrategy, DefaultMergeStrategy, DefaultSortingStrategy, DefaultTreeGridMergeStrategy, EDITOR_PROVIDER, ELEMENTS_TOKEN, ElasticPositionStrategy, ExpressionsTreeUtil, FilterUtil, FilteringExpressionsTree, FilteringExpressionsTreeType, FilteringLogic, FilteringStrategy, FormattedValuesFilteringStrategy, FormattedValuesSortingStrategy, GlobalPositionStrategy, GridColumnDataType, GridResourceStringsEN, GridSummaryCalculationMode, GroupMemberCountSortingStrategy, GroupedRecords, HEADER_KEYS, HORIZONTAL_NAV_KEYS, HammerGesturesManager, HorizontalAlignment, IgxActionStripActionsToken, IgxActionStripToken, IgxAngularAnimationPlayer, IgxAngularAnimationService, IgxBaseTransactionService, IgxBooleanFilteringOperand, IgxDataRecordSorting, IgxDateFilteringOperand, IgxDateTimeFilteringOperand, IgxFilteringOperand, IgxFlatTransactionFactory, IgxGrouping, IgxHierarchicalTransactionFactory, IgxHierarchicalTransactionService, IgxNavigationCloseDirective, IgxNavigationService, IgxNavigationToggleDirective, IgxNumberFilteringOperand, IgxOverlayOutletDirective, IgxOverlayService, IgxPickerActionsDirective, IgxPickerClearComponent, IgxPickerToggleComponent, IgxSelectionAPIService, IgxSorting, IgxStringFilteringOperand, IgxTimeFilteringOperand, IgxTransactionService, InputResourceStringsEN, ListResourceStringsEN, NAVIGATION_KEYS, NoOpScrollStrategy, NoopFilteringStrategy, NoopSortingStrategy, OffsetMode, PaginatorResourceStringsEN, PagingError, PerformanceService, PickerCalendarOrientation, PickerHeaderOrientation, PickerInteractionMode, PlatformUtil, Point, QueryBuilderResourceStringsEN, ROW_ADD_KEYS, ROW_COLLAPSE_KEYS, ROW_EXPAND_KEYS, RelativePosition, RelativePositionStrategy, SUPPORTED_KEYS, ScrollStrategy, SortingDirection, THEME_TOKEN, TRANSACTION_TYPE, ThemeToken, TimePickerResourceStringsEN, TransactionEventOrigin, TransactionType, TreeGridFilteringStrategy, TreeGridFormattedValuesFilteringStrategy, TreeGridMatchingRecordsOnlyFilteringStrategy, TreeResourceStringsEN, Util, VerticalAlignment, WEEKDAYS, areEqualArrays, areSameMonth, calendarRange, changei18n, clamp, clearAll, clearMeasures, cloneArray, cloneHierarchicalArray, cloneValue, cloneValueCached, columnFieldPath, compareMaps, copyDescriptors, daysInWeek, first, flatten, formatCurrency, formatDate, formatToParts, generateMonth, getClosestActiveDate, getComponentCssSizeVar, getComponentSize, getComponentTheme, getCurrentResourceStrings, getHierarchy, getMeasures, getNextActiveDate, getPreviousActiveDate, getResizeObserver, getYearRange, igxI18N, intoChunks, isConstructor, isDate, isDateInRanges, isEqual, isHierarchyMatch, isNextMonth, isObject, isPreviousMonth, isTree, last, mergeObjects, modulo, normalizeURI, parseDate, recreateTree, recreateTreeFromFields, rem, resizeObservable, resolveNestedPath, reverseMapper, showMessage, startMeasure, toCalendarDay, trackByIdentity, uniqueDates, yieldingLoop, DIR_DOCUMENT as ɵDIR_DOCUMENT, IgxDirectionality as ɵIgxDirectionality, Size$1 as ɵSize };
export type { Action, AnimationPlayer, AnimationService, CalendarRangeParams, CancelableBrowserEventArgs, CancelableEventArgs, ColumnType, ConnectedFit, CustomDateRange, DatePartDeltas, DatePartInfo, DateRange, DateRangeDescriptor, DayInterval, DayParameter, EditorProvider, EntityType, FieldType, GridTypeBase, HammerInput, HammerManager, HammerOptions, HammerStatic, HierarchicalState, HierarchicalTransaction, HierarchicalTransactionService, IActionStripResourceStrings, IBannerResourceStrings, IBaseCancelableBrowserEventArgs, IBaseCancelableEventArgs, IBaseEventArgs, ICalendarResourceStrings, ICarouselResourceStrings, IChipResourceStrings, IColumnEditorOptions, IColumnPipeArgs, IComboResourceStrings, IDataCloneStrategy, IDateParts, IDatePickerResourceStrings, IDateRangePickerResourceStrings, IExpressionTree, IFieldEditorOptions, IFieldPipeArgs, IFilteringExpression, IFilteringExpressionsTree, IFilteringOperation, IFilteringState, IFilteringStrategy, IGridGroupingStrategy, IGridMergeStrategy, IGridResourceStrings, IGridSortingStrategy, IGroupByExpandState, IGroupByKey, IGroupByRecord, IGroupByResult, IGroupingExpression, IGroupingState, IInputResourceStrings, IListResourceStrings, IMergeByResult, IPaginatorResourceStrings, IPagingState, IPathSegment, IPositionStrategy, IQueryBuilderResourceStrings, IResourceStrings, IScrollStrategy, ISortingExpression, ISortingOptions, ISortingStrategy, ISummaryExpression, ISummaryRecord, ITimePickerResourceStrings, IToggleView, ITreeGridRecord, ITreeResourceStrings, IgcCalendarBaseEventMap, IgxFilterItem, IgxSummaryResult, IgxTheme, IgxTreeGridAPIService, KeyOfOrString, MRLColumnSizeInfo, MRLResizeColumnInfo, OverlayAnimationEventArgs, OverlayCancelableEventArgs, OverlayClosingEventArgs, OverlayCreateSettings, OverlayEventArgs, OverlaySettings, PositionSettings, Recognizer, Size, State, StateUpdateEvent, Transaction, TransactionService, WeekDays, Direction as ɵDirection };