import * as node_modules_igniteui_grid_lite_components_row from 'node_modules/igniteui-grid-lite/components/row';
import * as _angular_core from '@angular/core';
import { TemplateRef, OnInit } from '@angular/core';
import { IgcCellContext, IgcHeaderContext, Keys, DataType, ColumnSortConfiguration, ColumnConfiguration, SortingExpression, FilterExpression, GridLiteSortingOptions, DataPipelineConfiguration } from 'igniteui-grid-lite';

/** Configuration object for grid columns. */
type IgxGridLiteColumnConfiguration<T extends object = any> = ColumnConfiguration<T>;
type IgxGridLiteColumnSortConfiguration<T extends object = any> = ColumnSortConfiguration<T>;
/**
 * Directive providing type information for header template contexts.
 * Use this directive on ng-template elements that render header templates.
 *
 * @example
 * ```html
 * <ng-template igxGridLiteHeader let-column>
 *   <div>{{column.header}}</div>
 * </ng-template>
 * ```
 */
declare class IgxGridLiteHeaderTemplateDirective<T extends object = any> {
    template: TemplateRef<IgxGridLiteHeaderTemplateContext<T>>;
    static ngTemplateContextGuard<T extends object = any>(_: IgxGridLiteHeaderTemplateDirective<T>, ctx: any): ctx is IgxGridLiteHeaderTemplateContext<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IgxGridLiteHeaderTemplateDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IgxGridLiteHeaderTemplateDirective<any>, "[igxGridLiteHeader]", never, {}, {}, never, never, true, never>;
}
/**
 * Directive providing type information for cell template contexts.
 * Use this directive on ng-template elements that render cell templates.
 *
 * @example
 * ```html
 * <ng-template igxGridLiteCell let-value let-column="column" let-rowIndex="rowIndex" let-data="data">
 *   <div>{{value}}</div>
 * </ng-template>
 * ```
 */
declare class IgxGridLiteCellTemplateDirective<T extends object = any> {
    template: TemplateRef<IgxGridLiteCellTemplateContext<T>>;
    static ngTemplateContextGuard<T extends object = any>(_: IgxGridLiteCellTemplateDirective<T>, ctx: unknown): ctx is IgxGridLiteCellTemplateContext<T>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IgxGridLiteCellTemplateDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IgxGridLiteCellTemplateDirective<any>, "[igxGridLiteCell]", never, {}, {}, never, never, true, never>;
}
declare class IgxGridLiteColumnComponent<T extends object = any> {
    private readonly _view;
    /** Reference to the embedded view for the header template and its template function. */
    private headerViewRef?;
    protected headerTemplateFunc?: (ctx: IgcHeaderContext<T>) => Node[];
    /** Reference to the embedded view for the cell template and its template function. */
    private cellViewRefs?;
    protected cellTemplateFunc?: (ctx: IgcCellContext<T>) => Node[];
    /** Template directives used for inline templating */
    private readonly headerTemplateDirective;
    private readonly cellTemplateDirective;
    /** The field from the data for this column. */
    readonly field: _angular_core.InputSignal<Keys<T>>;
    /** The data type of the column's values. */
    readonly dataType: _angular_core.InputSignal<DataType>;
    /** The header text of the column. */
    readonly header: _angular_core.InputSignal<string>;
    /** The width of the column. */
    readonly width: _angular_core.InputSignal<string>;
    /** Indicates whether the column is hidden. */
    readonly hidden: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Indicates whether the column is resizable. */
    readonly resizable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Indicates whether the column is sortable. */
    readonly sortable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether sort operations will be case sensitive. */
    readonly sortingCaseSensitive: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Sort configuration for the column (e.g., custom comparer). */
    readonly sortConfiguration: _angular_core.InputSignal<IgxGridLiteColumnSortConfiguration<T>>;
    /** Indicates whether the column is filterable. */
    readonly filterable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Whether filter operations will be case sensitive. */
    readonly filteringCaseSensitive: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Custom header template for the column. */
    readonly headerTemplate: _angular_core.InputSignal<TemplateRef<IgxGridLiteHeaderTemplateContext<T>>>;
    /** Custom cell template for the column. */
    readonly cellTemplate: _angular_core.InputSignal<TemplateRef<IgxGridLiteCellTemplateContext<T>>>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IgxGridLiteColumnComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IgxGridLiteColumnComponent<any>, "igx-grid-lite-column", never, { "field": { "alias": "field"; "required": false; "isSignal": true; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "sortingCaseSensitive": { "alias": "sortingCaseSensitive"; "required": false; "isSignal": true; }; "sortConfiguration": { "alias": "sortConfiguration"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "filteringCaseSensitive": { "alias": "filteringCaseSensitive"; "required": false; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; "isSignal": true; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; }, {}, ["headerTemplateDirective", "cellTemplateDirective"], never, true, never>;
}
/**
 * Context provided to the header template.
 */
type IgxGridLiteHeaderTemplateContext<T extends object = any> = IgcHeaderContext<T> & {
    /**
     * The current configuration for the column.
     */
    $implicit: IgcHeaderContext<T>['column'];
};
/**
 * Context provided to the header template.
 */
type IgxGridLiteCellTemplateContext<T extends object = any> = IgcCellContext<T> & {
    /**
     * The value from the data source for this cell.
     */
    $implicit: IgcCellContext<T>['value'];
};

type IgxGridLiteSortingOptions = GridLiteSortingOptions;
type IgxGridLiteDataPipelineConfiguration<T extends object = any> = DataPipelineConfiguration<T>;
type IgxGridLiteSortingExpression<T extends object = any> = SortingExpression<T>;
type IgxGridLiteFilteringExpression<T extends object = any> = FilterExpression<T>;
/**
 * The Grid Lite is a web component for displaying data in a tabular format quick and easy.
 *
 * Out of the box it provides row virtualization, sort and filter operations (client and server side),
 * the ability to template cells and headers and column hiding.
 *
 * @fires sorting - Emitted when sorting is initiated through the UI.
 * @fires sorted - Emitted when a sort operation initiated through the UI has completed.
 * @fires filtering - Emitted when filtering is initiated through the UI.
 * @fires filtered - Emitted when a filter operation initiated through the UI has completed.
 *
 * @developerPreview 21.1.0
 */
declare class IgxGridLiteComponent<T extends object = any> implements OnInit {
    private readonly gridRef;
    /** The data source for the grid. */
    readonly data: _angular_core.InputSignal<T[]>;
    /**
     * Whether the grid will try to "resolve" its column configuration based on the passed
     * data source.
     *
     * @remarks
     * This property is ignored if any existing column configuration already exists in the grid.
     */
    readonly autoGenerate: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /** Sort configuration property for the grid. */
    readonly sortingOptions: _angular_core.InputSignal<GridLiteSortingOptions>;
    /**
     * Configuration object which controls remote data operations for the grid.
     */
    readonly dataPipelineConfiguration: _angular_core.InputSignal<IgxGridLiteDataPipelineConfiguration<any>>;
    /**
     * The sort state for the grid.
     *
     * @remarks
     * This is a two-way bindable property. It will be updated when sort operations
     * complete through the UI.
     */
    readonly sortingExpressions: _angular_core.ModelSignal<IgxGridLiteSortingExpression<T>[]>;
    /**
     * The filter state for the grid.
     *
     * @remarks
     * This is a two-way bindable property. It will be updated when filter operations
     * complete through the UI.
     */
    readonly filteringExpressions: _angular_core.ModelSignal<IgxGridLiteFilteringExpression<T>[]>;
    /**
     * Get the column configuration of the grid.
     */
    get columns(): IgxGridLiteColumnConfiguration<T>[];
    /**
     * Returns the collection of rendered row elements in the grid.
     *
     * @remarks
     * Since the grid has virtualization, this property returns only the currently rendered
     * chunk of elements in the DOM.
     */
    get rows(): node_modules_igniteui_grid_lite_components_row.default<T>[];
    /**
     * Returns the state of the data source after sort/filter operations
     * have been applied.
     */
    get dataView(): ReadonlyArray<T>;
    constructor();
    /**
     * @hidden @internal
     */
    ngOnInit(): void;
    /**
     * Performs a filter operation in the grid based on the passed expression(s).
     */
    filter(config: IgxGridLiteFilteringExpression | IgxGridLiteFilteringExpression[]): void;
    /**
     * Performs a sort operation in the grid based on the passed expression(s).
     */
    sort(expressions: IgxGridLiteSortingExpression<T> | IgxGridLiteSortingExpression<T>[]): void;
    /**
     * Resets the current sort state of the control.
     */
    clearSort(key?: Keys<T>): void;
    /**
     * Resets the current filter state of the control.
     */
    clearFilter(key?: Keys<T>): void;
    /**
     * Navigates to a position in the grid based on provided row index and column field.
     * @param row The row index to navigate to
     * @param column The column field to navigate to, if any
     * @param activate Optionally also activate the navigated cell
     */
    navigateTo(row: number, column?: Keys<T>, activate?: boolean): Promise<void>;
    /**
     * Returns a {@link IgxGridLiteColumnConfiguration} for a given column.
     */
    getColumn(id: Keys<T> | number): IgxGridLiteColumnConfiguration<T> | undefined;
    protected onSorted(_event: CustomEvent<SortingExpression<T>>): void;
    protected onFiltered(_event: CustomEvent<FilterExpression<T>>): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IgxGridLiteComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IgxGridLiteComponent<any>, "igx-grid-lite", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "autoGenerate": { "alias": "autoGenerate"; "required": false; "isSignal": true; }; "sortingOptions": { "alias": "sortingOptions"; "required": false; "isSignal": true; }; "dataPipelineConfiguration": { "alias": "dataPipelineConfiguration"; "required": false; "isSignal": true; }; "sortingExpressions": { "alias": "sortingExpressions"; "required": false; "isSignal": true; }; "filteringExpressions": { "alias": "filteringExpressions"; "required": false; "isSignal": true; }; }, { "sortingExpressions": "sortingExpressionsChange"; "filteringExpressions": "filteringExpressionsChange"; }, never, ["*"], true, never>;
}
declare global {
    interface HTMLElementTagNameMap {
    }
    interface HTMLElementEventMap {
        'sorting': CustomEvent<IgxGridLiteSortingExpression<any>>;
        'sorted': CustomEvent<IgxGridLiteSortingExpression<any>>;
        'filtering': CustomEvent<IgxGridLiteFilteringExpression<any>>;
        'filtered': CustomEvent<IgxGridLiteFilteringExpression<any>>;
    }
}

export { IgxGridLiteCellTemplateDirective, IgxGridLiteColumnComponent, IgxGridLiteComponent, IgxGridLiteHeaderTemplateDirective };
export type { IgxGridLiteCellTemplateContext, IgxGridLiteColumnConfiguration, IgxGridLiteColumnSortConfiguration, IgxGridLiteDataPipelineConfiguration, IgxGridLiteFilteringExpression, IgxGridLiteHeaderTemplateContext, IgxGridLiteSortingExpression, IgxGridLiteSortingOptions };