ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/export/baseCreator.d.ts

@@ -0,0 +1,13 @@
+import { BeanStub } from '../context/beanStub';
+import type { ExportParams } from '../interfaces/exportParams';
+import type { GridSerializingSession } from './iGridSerializer';
+export declare abstract class BaseCreator<T, S extends GridSerializingSession<T>, P extends ExportParams<T>> extends BeanStub {
+    protected abstract export(userParams?: P, compress?: boolean): void;
+    protected abstract getMergedParams(params?: P): P;
+    protected getFileName(fileName?: string): string;
+    protected getData(params: P): string;
+    getDefaultFileName(): string;
+    abstract createSerializingSession(params?: P): S;
+    abstract getDefaultFileExtension(): string;
+    abstract isExportSuppressed(): boolean;
+}

package/dist/types/src/export/baseGridSerializingSession.d.ts

@@ -0,0 +1,37 @@
+import type { ColumnModel } from '../columns/columnModel';
+import type { AgColumn } from '../entities/agColumn';
+import type { RowNode } from '../entities/rowNode';
+import type { GridOptionsService } from '../gridOptionsService';
+import type { ProcessCellForExportParams, ProcessGroupHeaderForExportParams, ProcessHeaderForExportParams, ProcessRowGroupForExportParams } from '../interfaces/exportParams';
+import type { IColsService } from '../interfaces/iColsService';
+import type { ValueService } from '../valueService/valueService';
+import type { RowAccumulator, RowSpanningAccumulator } from './iGridSerializer';
+import type { GridSerializingParams, GridSerializingSession } from './iGridSerializer';
+export declare abstract class BaseGridSerializingSession<T> implements GridSerializingSession<T> {
+    colModel: ColumnModel;
+    private colNames;
+    rowGroupColsSvc?: IColsService;
+    valueSvc: ValueService;
+    gos: GridOptionsService;
+    processCellCallback?: (params: ProcessCellForExportParams) => string;
+    processHeaderCallback?: (params: ProcessHeaderForExportParams) => string;
+    processGroupHeaderCallback?: (params: ProcessGroupHeaderForExportParams) => string;
+    processRowGroupCallback?: (params: ProcessRowGroupForExportParams) => string;
+    private groupColumns;
+    constructor(config: GridSerializingParams);
+    abstract addCustomContent(customContent: T): void;
+    abstract onNewHeaderGroupingRow(): RowSpanningAccumulator;
+    abstract onNewHeaderRow(): RowAccumulator;
+    abstract onNewBodyRow(node?: RowNode): RowAccumulator;
+    abstract parse(): string;
+    prepare(columnsToExport: AgColumn[]): void;
+    extractHeaderValue(column: AgColumn): string;
+    extractRowCellValue(column: AgColumn, index: number, accumulatedRowIndex: number, type: string, node: RowNode): {
+        value: any;
+        valueFormatted?: string | null;
+    };
+    private shouldRenderGroupSummaryCell;
+    private getHeaderName;
+    private createValueForGroupNode;
+    private processCell;
+}

package/dist/types/src/export/downloader.d.ts

@@ -0,0 +1 @@
+export declare function _downloadFile(fileName: string, content: Blob): void;

package/dist/types/src/export/exportModule.d.ts

@@ -0,0 +1,5 @@
+import type { _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const SharedExportModule: _ModuleWithoutApi;

package/dist/types/src/export/gridSerializer.d.ts

@@ -0,0 +1,27 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { ExportParams } from '../interfaces/exportParams';
+import type { GridSerializingSession } from './iGridSerializer';
+export declare class GridSerializer extends BeanStub implements NamedBean {
+    beanName: "gridSerializer";
+    private visibleCols;
+    private colModel;
+    private rowModel;
+    private pinnedRowModel?;
+    wireBeans(beans: BeanCollection): void;
+    serialize<T>(gridSerializingSession: GridSerializingSession<T>, params?: ExportParams<T>): string;
+    private processRow;
+    private appendContent;
+    private prependContent;
+    private prepareSession;
+    private exportColumnGroups;
+    private exportHeaders;
+    private processPinnedTopRows;
+    private processRows;
+    private replicateSortedOrder;
+    private processPinnedBottomRows;
+    private getColumnsToExport;
+    private recursivelyAddHeaderGroups;
+    private doAddHeaderHeader;
+}

package/dist/types/src/export/iGridSerializer.d.ts

@@ -0,0 +1,37 @@
+import type { ColumnModel } from '../columns/columnModel';
+import type { ColumnNameService } from '../columns/columnNameService';
+import type { AgColumn } from '../entities/agColumn';
+import type { RowNode } from '../entities/rowNode';
+import type { GridOptionsService } from '../gridOptionsService';
+import type { ProcessCellForExportParams, ProcessGroupHeaderForExportParams, ProcessHeaderForExportParams, ProcessRowGroupForExportParams } from '../interfaces/exportParams';
+import type { IColsService } from '../interfaces/iColsService';
+import type { ColumnGroup } from '../interfaces/iColumn';
+import type { ValueService } from '../valueService/valueService';
+export interface RowAccumulator {
+    onColumn(column: AgColumn, index: number, node?: RowNode): void;
+}
+export interface RowSpanningAccumulator {
+    onColumn(columnGroup: ColumnGroup, header: string, index: number, span: number, collapsibleGroupRanges: number[][]): void;
+}
+export interface GridSerializingParams {
+    colModel: ColumnModel;
+    rowGroupColsSvc?: IColsService;
+    colNames: ColumnNameService;
+    valueSvc: ValueService;
+    gos: GridOptionsService;
+    processCellCallback?: (params: ProcessCellForExportParams) => string;
+    processHeaderCallback?: (params: ProcessHeaderForExportParams) => string;
+    processGroupHeaderCallback?: (params: ProcessGroupHeaderForExportParams) => string;
+    processRowGroupCallback?: (params: ProcessRowGroupForExportParams) => string;
+}
+export interface GridSerializingSession<T> {
+    prepare(columnsToExport: AgColumn[]): void;
+    onNewHeaderGroupingRow(): RowSpanningAccumulator;
+    onNewHeaderRow(): RowAccumulator;
+    onNewBodyRow(node?: RowNode): RowAccumulator;
+    addCustomContent(customContent: T): void;
+    /**
+     * FINAL RESULT
+     */
+    parse(): string;
+}

package/dist/types/src/filter/column-filters.css-GENERATED.d.ts

@@ -0,0 +1 @@
+export declare const columnFiltersCSS = ".ag-set-filter{--ag-indentation-level:0}.ag-set-filter-item{align-items:center;display:flex;height:100%}:where(.ag-ltr) .ag-set-filter-item{padding-left:calc(var(--ag-widget-container-horizontal-padding) + var(--ag-indentation-level)*var(--ag-set-filter-indent-size))}:where(.ag-rtl) .ag-set-filter-item{padding-right:calc(var(--ag-widget-container-horizontal-padding) + var(--ag-indentation-level)*var(--ag-set-filter-indent-size))}.ag-set-filter-item-checkbox{display:flex;height:100%;width:100%}.ag-set-filter-group-icons{display:block;>*{cursor:pointer}}:where(.ag-ltr) .ag-set-filter-group-icons{margin-right:var(--ag-widget-container-horizontal-padding)}:where(.ag-rtl) .ag-set-filter-group-icons{margin-left:var(--ag-widget-container-horizontal-padding)}.ag-filter-body-wrapper{display:flex;flex-direction:column}:where(.ag-menu:not(.ag-tabs) .ag-filter) .ag-filter-body-wrapper,:where(.ag-menu:not(.ag-tabs) .ag-filter)>:not(.ag-filter-wrapper){min-width:180px}.ag-filter-filter{flex:1 1 0px}.ag-filter-condition{display:flex;justify-content:center}.ag-floating-filter-body{display:flex;flex:1 1 auto;height:100%;position:relative}.ag-floating-filter-full-body{align-items:center;display:flex;flex:1 1 auto;height:100%;overflow:hidden;width:100%}.ag-floating-filter-input{align-items:center;display:flex;width:100%;>*{flex:1 1 auto}:where(.ag-input-field-input[type=date]){width:1px}}.ag-floating-filter-button{display:flex;flex:none}.ag-set-floating-filter-input [disabled]{pointer-events:none}.ag-floating-filter-button-button{-webkit-appearance:none;-moz-appearance:none;appearance:none;border:none;height:var(--ag-icon-size);width:var(--ag-icon-size)}.ag-filter-loading{background-color:var(--ag-chrome-background-color);height:100%;padding:var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding);position:absolute;width:100%;z-index:1;:where(.ag-menu) &{background-color:var(--ag-menu-background-color)}}.ag-filter-separator{border-top:1px solid var(--menu-separator-color)}:where(.ag-filter-select) .ag-picker-field-wrapper{width:0}.ag-filter-condition-operator{height:17px}:where(.ag-ltr) .ag-filter-condition-operator-or{margin-left:calc(var(--ag-spacing)*2)}:where(.ag-rtl) .ag-filter-condition-operator-or{margin-right:calc(var(--ag-spacing)*2)}.ag-set-filter-select-all{padding-top:var(--ag-widget-container-vertical-padding)}.ag-filter-no-matches,.ag-set-filter-list{height:calc(var(--ag-list-item-height)*6)}.ag-filter-no-matches{padding:var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding)}.ag-set-filter-tree-list{height:calc(var(--ag-list-item-height)*10)}.ag-set-filter-filter{margin-left:var(--ag-widget-container-horizontal-padding);margin-right:var(--ag-widget-container-horizontal-padding);margin-top:var(--ag-widget-container-vertical-padding)}.ag-filter-to{margin-top:var(--ag-widget-vertical-spacing)}.ag-mini-filter{margin:var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding)}:where(.ag-ltr) .ag-set-filter-add-group-indent{margin-left:calc(var(--ag-icon-size) + var(--ag-widget-container-horizontal-padding))}:where(.ag-rtl) .ag-set-filter-add-group-indent{margin-right:calc(var(--ag-icon-size) + var(--ag-widget-container-horizontal-padding))}:where(.ag-filter-menu) .ag-set-filter-list{min-width:200px}.ag-filter-virtual-list-item:focus-visible{box-shadow:inset var(--ag-focus-shadow)}.ag-filter-apply-panel{display:flex;justify-content:flex-end;overflow:hidden;padding:var(--ag-widget-vertical-spacing) var(--ag-widget-container-horizontal-padding) var(--ag-widget-container-vertical-padding)}.ag-filter-apply-panel-button{line-height:1.5}:where(.ag-ltr) .ag-filter-apply-panel-button{margin-left:calc(var(--ag-spacing)*2)}:where(.ag-rtl) .ag-filter-apply-panel-button{margin-right:calc(var(--ag-spacing)*2)}.ag-simple-filter-body-wrapper{display:flex;flex-direction:column;min-height:calc(var(--ag-list-item-height) + var(--ag-widget-container-vertical-padding) + var(--ag-widget-vertical-spacing));overflow-y:auto;padding:var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding);padding-bottom:calc(var(--ag-widget-container-vertical-padding) - var(--ag-widget-vertical-spacing));&>*{margin-bottom:var(--ag-widget-vertical-spacing)}:where(.ag-resizer-wrapper){margin:0}}.ag-multi-filter-menu-item{margin:var(--ag-spacing) 0}.ag-multi-filter-group-title-bar{background-color:transparent;color:var(--ag-header-text-color);font-weight:500;padding:calc(var(--ag-spacing)*1.5) var(--ag-spacing)}.ag-group-filter-field-select-wrapper{display:flex;flex-direction:column;gap:var(--ag-widget-vertical-spacing);padding:var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding)}";

package/dist/types/src/filter/columnFilterApi.d.ts

@@ -0,0 +1,11 @@
+import type { BeanCollection } from '../context/context';
+import type { Column } from '../interfaces/iColumn';
+import type { FilterModel, IFilter } from '../interfaces/iFilter';
+export declare function isColumnFilterPresent(beans: BeanCollection): boolean;
+export declare function getColumnFilterInstance<TFilter extends IFilter>(beans: BeanCollection, key: string | Column): Promise<TFilter | null | undefined>;
+export declare function destroyFilter(beans: BeanCollection, key: string | Column): void;
+export declare function setFilterModel(beans: BeanCollection, model: FilterModel | null): void;
+export declare function getFilterModel(beans: BeanCollection): FilterModel;
+export declare function getColumnFilterModel<TModel>(beans: BeanCollection, column: string | Column): TModel | null;
+export declare function setColumnFilterModel<TModel>(beans: BeanCollection, column: string | Column, model: TModel | null): Promise<void>;
+export declare function showColumnFilter(beans: BeanCollection, colKey: string | Column): void;

package/dist/types/src/filter/columnFilterService.d.ts

@@ -0,0 +1,81 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanName } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColDef } from '../entities/colDef';
+import type { CoreDataTypeDefinition, DataTypeFormatValueFunc } from '../entities/dataType';
+import type { RowNode } from '../entities/rowNode';
+import type { ColumnEventType, FilterChangedEventSourceType } from '../events';
+import type { FilterModel, IFilter, IFilterComp, IFilterParams } from '../interfaces/iFilter';
+import type { UserCompDetails } from '../interfaces/iUserCompDetails';
+import { AgPromise } from '../utils/promise';
+export declare class ColumnFilterService extends BeanStub implements NamedBean {
+    beanName: BeanName;
+    private allColumnFilters;
+    private allColumnListeners;
+    private activeAggregateFilters;
+    private activeColumnFilters;
+    private processingFilterChange;
+    private filterModelUpdateQueue;
+    private columnFilterModelUpdateQueue;
+    private initialFilterModel;
+    postConstruct(): void;
+    setFilterModel(model: FilterModel | null, source?: FilterChangedEventSourceType): void;
+    getFilterModel(excludeInitialState?: boolean): FilterModel;
+    private getModelFromFilterWrapper;
+    private getModelFromInitialState;
+    isColumnFilterPresent(): boolean;
+    isAggregateFilterPresent(): boolean;
+    disableColumnFilters(): boolean;
+    doAggregateFiltersPass(node: RowNode, filterToSkip?: IFilterComp): boolean;
+    private updateActiveFilters;
+    private updateFilterFlagInColumns;
+    private forEachColumnFilter;
+    doColumnFiltersPass(node: RowNode, filterToSkip?: IFilterComp, targetAggregates?: boolean): boolean;
+    private callOnFilterChangedOutsideRenderCycle;
+    updateBeforeFilterChanged(params?: {
+        filterInstance?: IFilterComp;
+        additionalEventAttributes?: any;
+    }): AgPromise<void>;
+    updateAfterFilterChanged(): void;
+    isSuppressFlashingCellsBecauseFiltering(): boolean;
+    private onNewRowsLoaded;
+    private createGetValue;
+    isFilterActive(column: AgColumn): boolean;
+    getOrCreateFilterWrapper(column: AgColumn): FilterWrapper | null;
+    private cachedFilter;
+    private getDefaultFilter;
+    getDefaultFloatingFilter(column: AgColumn): string;
+    private createFilterInstance;
+    createFilterParams(column: AgColumn, colDef: ColDef): IFilterParams;
+    private createFilterWrapper;
+    private onColumnsChanged;
+    private updateDependentFilters;
+    isFilterAllowed(column: AgColumn): boolean;
+    getFloatingFilterCompDetails(column: AgColumn, showParentFilter: () => void): UserCompDetails | undefined;
+    getCurrentFloatingFilterParentModel(column: AgColumn): any;
+    destroyFilter(column: AgColumn, source?: 'api' | 'columnChanged' | 'paramsUpdated'): void;
+    private disposeColumnListener;
+    private disposeFilterWrapper;
+    private filterModifiedCallbackFactory;
+    private filterChangedCallbackFactory;
+    private checkDestroyFilter;
+    private setColumnFilterWrapper;
+    areFilterCompsDifferent(oldCompDetails: UserCompDetails | null, newCompDetails: UserCompDetails | null): boolean;
+    hasFloatingFilters(): boolean;
+    getColumnFilterInstance<TFilter extends IFilter>(key: string | AgColumn): Promise<TFilter | null | undefined>;
+    private getFilterInstanceImpl;
+    private processFilterModelUpdateQueue;
+    getColumnFilterModel(key: string | AgColumn): any;
+    setColumnFilterModel(key: string | AgColumn, model: any): Promise<void>;
+    private getFilterWrapper;
+    setColDefPropertiesForDataType(colDef: ColDef, dataTypeDefinition: CoreDataTypeDefinition, formatValue: DataTypeFormatValueFunc): void;
+    setColFilterActive(column: AgColumn, active: boolean, source: ColumnEventType, additionalEventAttributes?: any): void;
+    destroy(): void;
+}
+export interface FilterWrapper {
+    column: AgColumn;
+    filterPromise: AgPromise<IFilterComp> | null;
+    filter?: IFilterComp;
+    compDetails: UserCompDetails | null;
+}

package/dist/types/src/filter/filterManager.d.ts

@@ -0,0 +1,82 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColDef } from '../entities/colDef';
+import type { CoreDataTypeDefinition, DataTypeFormatValueFunc } from '../entities/dataType';
+import type { RowNode } from '../entities/rowNode';
+import type { FilterChangedEventSourceType } from '../events';
+import type { AdvancedFilterModel } from '../interfaces/advancedFilterModel';
+import type { FilterModel, IFilter, IFilterComp, IFilterParams } from '../interfaces/iFilter';
+import type { UserCompDetails } from '../interfaces/iUserCompDetails';
+import type { FilterWrapper } from './columnFilterService';
+export declare class FilterManager extends BeanStub implements NamedBean {
+    beanName: "filterManager";
+    private quickFilter?;
+    private advancedFilter;
+    private colFilter?;
+    wireBeans(beans: BeanCollection): void;
+    private externalFilterPresent;
+    private aggFiltering;
+    private advFilterModelUpdateQueue;
+    private alwaysPassFilter?;
+    postConstruct(): void;
+    private isExternalFilterPresentCallback;
+    private doesExternalFilterPass;
+    setFilterModel(model: FilterModel | null, source?: FilterChangedEventSourceType): void;
+    getFilterModel(): FilterModel;
+    isColumnFilterPresent(): boolean;
+    isAggregateFilterPresent(): boolean;
+    isChildFilterPresent(): boolean;
+    isAnyFilterPresent(): boolean;
+    private isAdvFilterPresent;
+    private onAdvFilterEnabledChanged;
+    isAdvFilterEnabled(): boolean;
+    isAdvFilterHeaderActive(): boolean;
+    resetQuickFilterCache(): void;
+    private refreshFiltersForAggregations;
+    onFilterChanged(params?: {
+        source?: FilterChangedEventSourceType;
+        filterInstance?: IFilterComp;
+        additionalEventAttributes?: any;
+        columns?: AgColumn[];
+    }): void;
+    isSuppressFlashingCellsBecauseFiltering(): boolean;
+    isQuickFilterPresent(): boolean;
+    private updateAggFiltering;
+    isAggregateQuickFilterPresent(): boolean;
+    private isNonAggregateQuickFilterPresent;
+    private shouldApplyQuickFilterAfterAgg;
+    doesRowPassOtherFilters(filterToSkip: IFilterComp, node: any): boolean;
+    doesRowPassAggregateFilters(params: {
+        rowNode: RowNode;
+        filterInstanceToSkip?: IFilterComp;
+    }): boolean;
+    doesRowPassFilter(params: {
+        rowNode: RowNode;
+        filterInstanceToSkip?: IFilterComp;
+    }): boolean;
+    isFilterActive(column: AgColumn): boolean;
+    getOrCreateFilterWrapper(column: AgColumn): FilterWrapper | null;
+    getDefaultFloatingFilter(column: AgColumn): string;
+    createFilterParams(column: AgColumn, colDef: ColDef): IFilterParams;
+    isFilterAllowed(column: AgColumn): boolean;
+    getFloatingFilterCompDetails(column: AgColumn, showParentFilter: () => void): UserCompDetails | undefined;
+    getCurrentFloatingFilterParentModel(column: AgColumn): any;
+    destroyFilter(column: AgColumn, source?: 'api' | 'columnChanged' | 'paramsUpdated'): void;
+    areFilterCompsDifferent(oldCompDetails: UserCompDetails | null, newCompDetails: UserCompDetails | null): boolean;
+    getAdvFilterModel(): AdvancedFilterModel | null;
+    setAdvFilterModel(expression: AdvancedFilterModel | null | undefined): void;
+    toggleAdvFilterBuilder(show: boolean, source: 'api' | 'ui'): void;
+    private updateAdvFilterColumns;
+    hasFloatingFilters(): boolean;
+    getColumnFilterInstance<TFilter extends IFilter>(key: string | AgColumn): Promise<TFilter | null | undefined>;
+    private warnAdvFilters;
+    setupAdvFilterHeaderComp(eCompToInsertBefore: HTMLElement): void;
+    getHeaderRowCount(): number;
+    getHeaderHeight(): number;
+    private processFilterModelUpdateQueue;
+    getColumnFilterModel(key: string | AgColumn): any;
+    setColumnFilterModel(key: string | AgColumn, model: any): Promise<void>;
+    setColDefPropertiesForDataType(colDef: ColDef, dataTypeDefinition: CoreDataTypeDefinition, formatValue: DataTypeFormatValueFunc): void;
+}

package/dist/types/src/filter/filterMenuFactory.d.ts

@@ -0,0 +1,23 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanCollection } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { ContainerType } from '../interfaces/iAfterGuiAttachedParams';
+import type { IMenuFactory } from '../interfaces/iMenuFactory';
+export declare class FilterMenuFactory extends BeanStub implements NamedBean, IMenuFactory {
+    beanName: "filterMenuFactory";
+    private popupSvc?;
+    wireBeans(beans: BeanCollection): void;
+    private hidePopup;
+    private tabListener;
+    private activeMenu?;
+    hideActiveMenu(): void;
+    showMenuAfterMouseEvent(column: AgColumn | undefined, mouseEvent: MouseEvent | Touch, containerType: ContainerType): void;
+    showMenuAfterButtonClick(column: AgColumn | undefined, eventSource: HTMLElement, containerType: ContainerType): void;
+    private showPopup;
+    private trapFocusWithin;
+    private dispatchVisibleChangedEvent;
+    isMenuEnabled(column: AgColumn): boolean;
+    showMenuAfterContextMenuEvent(): void;
+    destroy(): void;
+}

package/dist/types/src/filter/filterModule.d.ts

@@ -0,0 +1,45 @@
+import type { _ColumnFilterGridApi, _FilterGridApi, _QuickFilterGridApi } from '../api/gridApi';
+import type { _ModuleWithApi } from '../interfaces/iModule';
+import type { _ModuleWithoutApi } from '../interfaces/iModule';
+/**
+ * @internal
+ */
+export declare const ClientSideRowModelFilterModule: _ModuleWithoutApi;
+/**
+ * @internal
+ */
+export declare const FilterCoreModule: _ModuleWithApi<_FilterGridApi>;
+/**
+ * @internal
+ */
+export declare const FilterValueModule: _ModuleWithoutApi;
+/**
+ * @internal
+ */
+export declare const ColumnFilterModule: _ModuleWithApi<_ColumnFilterGridApi>;
+/**
+ * @feature Filtering -> Custom Column Filters
+ */
+export declare const CustomFilterModule: _ModuleWithoutApi;
+/**
+ * @feature Filtering -> Text Filter
+ */
+export declare const TextFilterModule: _ModuleWithoutApi;
+/**
+ * @feature Filtering -> Number Filter
+ */
+export declare const NumberFilterModule: _ModuleWithoutApi;
+/**
+ * @feature Filtering -> Date Filter
+ */
+export declare const DateFilterModule: _ModuleWithoutApi;
+/**
+ * @feature Filtering -> Quick Filter
+ * @gridOption quickFilterText
+ */
+export declare const QuickFilterModule: _ModuleWithApi<_QuickFilterGridApi>;
+/**
+ * @feature Filtering -> External Filter
+ * @gridOption doesExternalFilterPass
+ */
+export declare const ExternalFilterModule: _ModuleWithoutApi;

package/dist/types/src/filter/filterValueService.d.ts

@@ -0,0 +1,10 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { BeanName } from '../context/context';
+import type { AgColumn } from '../entities/agColumn';
+import type { IRowNode } from '../interfaces/iRowNode';
+export declare class FilterValueService extends BeanStub implements NamedBean {
+    beanName: BeanName;
+    getValue(column: AgColumn, rowNode?: IRowNode | null): any;
+    private executeFilterValueGetter;
+}

package/dist/types/src/filter/filterWrapperComp.d.ts

@@ -0,0 +1,21 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { IAfterGuiAttachedParams } from '../interfaces/iAfterGuiAttachedParams';
+import type { IFilterComp } from '../interfaces/iFilter';
+import { AgPromise } from '../utils/promise';
+import { Component } from '../widgets/component';
+import type { FilterRequestSource } from './iColumnFilter';
+export declare class FilterWrapperComp extends Component {
+    private readonly column;
+    private readonly source;
+    private filterWrapper;
+    constructor(column: AgColumn, source: FilterRequestSource);
+    postConstruct(): void;
+    hasFilter(): boolean;
+    getFilter(): AgPromise<IFilterComp> | null;
+    afterInit(): AgPromise<void>;
+    afterGuiAttached(params?: IAfterGuiAttachedParams): void;
+    afterGuiDetached(): void;
+    private createFilter;
+    private onFilterDestroyed;
+    destroy(): void;
+}

package/dist/types/src/filter/floating/floatingFilter.d.ts

@@ -0,0 +1,76 @@
+import type { FilterChangedEvent } from '../../events';
+import type { Column } from '../../interfaces/iColumn';
+import type { AgGridCommon } from '../../interfaces/iCommon';
+import type { IComponent } from '../../interfaces/iComponent';
+import type { IFilter, IFilterParams, ProvidedFilterModel } from '../../interfaces/iFilter';
+export interface IFloatingFilterParent {
+    /**
+     * Notification that a new floating-filter value was input by the user.
+     *
+     * @param type operation type selected.
+     * @param value model-typed value entered.
+     */
+    onFloatingFilterChanged(type: string | null, value: any): void;
+}
+type InbuiltParentType = IFloatingFilterParent & IFilter;
+export type IFloatingFilterParentCallback<P = InbuiltParentType> = (parentFilterInstance: P) => void;
+export interface IFloatingFilterParams<P = InbuiltParentType, TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The column this filter is for. */
+    column: Column;
+    /**
+     * The params object passed to the filter.
+     * This is to allow the floating filter access to the configuration of the parent filter.
+     * For example, the provided filters use debounceMs from the parent filter params.
+     * */
+    filterParams: IFilterParams;
+    /**
+     * This is a shortcut to invoke getModel on the parent filter.
+     * If the parent filter doesn't exist (filters are lazily created as needed)
+     * then it returns null rather than calling getModel() on the parent filter.
+     */
+    currentParentModel: () => any;
+    /**
+     * Gets a reference to the parent filter. The result is returned asynchronously
+     * via a callback as the parent filter may not exist yet. If it does
+     * not exist, it is created and asynchronously returned (AG Grid itself
+     * does not create components asynchronously, however if providing a framework
+     * provided filter e.g. React, it might be).
+     *
+     * The floating filter can then call any method it likes on the parent filter.
+     * The parent filter will typically provide its own method for the floating
+     * filter to call to set the filter. For example, if creating custom filter A,
+     * it should have a method your floating A can call to set the state
+     * when the user updates via the floating filter.
+     */
+    parentFilterInstance: (callback: IFloatingFilterParentCallback<P>) => void;
+    /**
+     * Shows the parent filter popup.
+     */
+    showParentFilter: () => void;
+}
+export interface BaseFloatingFilter {
+    /**
+     * Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen.
+     * If a parent popup is closed and reopened (e.g. for filters), this method is called each time the component is shown.
+     * This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.
+     */
+    afterGuiAttached?(): void;
+}
+export interface IFloatingFilter<P = any> extends BaseFloatingFilter {
+    /**
+     * Gets called every time the parent filter changes.
+     * Your floating filter would typically refresh its UI to reflect the new filter state.
+     * The provided parentModel is what the parent filter returns from its getModel() method.
+     * The event is the FilterChangedEvent that the grid fires.
+     */
+    onParentModelChanged(parentModel: any, filterChangedEvent?: FilterChangedEvent | null): void;
+    /** A hook to perform any necessary operations when the column definition is updated. */
+    refresh?(params: IFloatingFilterParams<P>): void;
+}
+export interface IFloatingFilterComp<P = any> extends IFloatingFilter<P>, IComponent<IFloatingFilterParams<P>> {
+}
+export interface BaseFloatingFilterChange {
+    model: ProvidedFilterModel;
+    apply: boolean;
+}
+export {};

package/dist/types/src/filter/floating/floatingFilterMapper.d.ts

@@ -0,0 +1,3 @@
+import type { IFilterDef } from '../../interfaces/iFilter';
+import type { IFrameworkOverrides } from '../../interfaces/iFrameworkOverrides';
+export declare function _getDefaultFloatingFilterType(frameworkOverrides: IFrameworkOverrides, def: IFilterDef, getFromDefault: () => string): string | null;

package/dist/types/src/filter/floating/provided/floatingFilterTextInputService.d.ts

@@ -0,0 +1,20 @@
+import { BeanStub } from '../../../context/beanStub';
+import type { AgInputTextFieldParams } from '../../../widgets/agInputTextField';
+import type { FloatingFilterInputService } from './iFloatingFilterInputService';
+export declare class FloatingFilterTextInputService extends BeanStub implements FloatingFilterInputService {
+    private params?;
+    private eInput;
+    private onValueChanged;
+    constructor(params?: {
+        config?: AgInputTextFieldParams | undefined;
+    } | undefined);
+    setupGui(parentElement: HTMLElement): void;
+    setEditable(editable: boolean): void;
+    getValue(): string | null | undefined;
+    setValue(value: string | null | undefined, silent?: boolean): void;
+    setValueChangedListener(listener: (e: KeyboardEvent) => void): void;
+    setParams({ ariaLabel, autoComplete }: {
+        ariaLabel: string;
+        autoComplete?: boolean | string;
+    }): void;
+}

package/dist/types/src/filter/floating/provided/readOnlyFloatingFilter.d.ts

@@ -0,0 +1,11 @@
+import type { IFilter } from '../../../interfaces/iFilter';
+import { Component } from '../../../widgets/component';
+import type { IFloatingFilterComp, IFloatingFilterParams, IFloatingFilterParent } from '../floatingFilter';
+export declare class ReadOnlyFloatingFilter extends Component implements IFloatingFilterComp<IFilter & IFloatingFilterParent> {
+    private readonly eFloatingFilterText;
+    private params;
+    constructor();
+    init(params: IFloatingFilterParams): void;
+    onParentModelChanged(parentModel: any): void;
+    refresh(params: IFloatingFilterParams): void;
+}

package/dist/types/src/filter/floating/provided/simpleFloatingFilter.d.ts

@@ -0,0 +1,25 @@
+import type { FilterChangedEvent } from '../../../events';
+import type { ProvidedFilterModel } from '../../../interfaces/iFilter';
+import { Component } from '../../../widgets/component';
+import type { ISimpleFilter } from '../../provided/iSimpleFilter';
+import { OptionsFactory } from '../../provided/optionsFactory';
+import type { SimpleFilterModelFormatter } from '../../provided/simpleFilterModelFormatter';
+import type { IFloatingFilterComp, IFloatingFilterParams } from '../floatingFilter';
+export declare abstract class SimpleFloatingFilter extends Component implements IFloatingFilterComp<ISimpleFilter> {
+    abstract onParentModelChanged(model: ProvidedFilterModel, event: FilterChangedEvent): void;
+    protected abstract getDefaultOptions(): string[];
+    protected abstract setEditable(editable: boolean): void;
+    protected abstract filterModelFormatter: SimpleFilterModelFormatter;
+    protected lastType: string | null | undefined;
+    protected optionsFactory: OptionsFactory;
+    protected readOnly: boolean;
+    protected defaultDebounceMs: number;
+    protected setLastTypeFromModel(model: ProvidedFilterModel): void;
+    protected canWeEditAfterModelFromParentFilter(model: ProvidedFilterModel): boolean;
+    init(params: IFloatingFilterParams): void;
+    private setSimpleParams;
+    refresh(params: IFloatingFilterParams): void;
+    private hasSingleInput;
+    private isTypeEditable;
+    protected getAriaLabel(params: IFloatingFilterParams): string;
+}

package/dist/types/src/filter/floating/provided/textInputFloatingFilter.d.ts

@@ -0,0 +1,24 @@
+import type { FilterChangedEvent } from '../../../events';
+import type { NumberFilterModel } from '../../provided/number/iNumberFilter';
+import type { ITextInputFloatingFilterParams, TextFilterModel } from '../../provided/text/iTextFilter';
+import type { FloatingFilterInputService } from './iFloatingFilterInputService';
+import { SimpleFloatingFilter } from './simpleFloatingFilter';
+type ModelUnion = TextFilterModel | NumberFilterModel;
+export declare abstract class TextInputFloatingFilter<M extends ModelUnion> extends SimpleFloatingFilter {
+    private readonly eFloatingFilterInputContainer;
+    private inputSvc;
+    protected params: ITextInputFloatingFilterParams;
+    private applyActive;
+    protected abstract createFloatingFilterInputService(params: ITextInputFloatingFilterParams): FloatingFilterInputService;
+    postConstruct(): void;
+    protected defaultDebounceMs: number;
+    onParentModelChanged(model: M, event: FilterChangedEvent): void;
+    init(params: ITextInputFloatingFilterParams): void;
+    private setupFloatingFilterInputService;
+    private setTextInputParams;
+    refresh(params: ITextInputFloatingFilterParams): void;
+    protected recreateFloatingFilterInputService(params: ITextInputFloatingFilterParams): void;
+    private syncUpWithParentFilter;
+    protected setEditable(editable: boolean): void;
+}
+export {};

package/dist/types/src/filter/provided/date/dateCompWrapper.d.ts

@@ -0,0 +1,25 @@
+import type { UserComponentFactory } from '../../../components/framework/userComponentFactory';
+import type { Context } from '../../../context/context';
+import type { IDateParams } from '../../../interfaces/dateComponent';
+import type { IAfterGuiAttachedParams } from '../../../interfaces/iAfterGuiAttachedParams';
+import type { WithoutGridCommon } from '../../../interfaces/iCommon';
+/** Provides sync access to async component. Date component can be lazy created - this class encapsulates
+ * this by keeping value locally until DateComp has loaded, then passing DateComp the value. */
+export declare class DateCompWrapper {
+    private dateComp;
+    private tempValue;
+    private disabled;
+    private alive;
+    private context;
+    private eParent;
+    constructor(context: Context, userCompFactory: UserComponentFactory, dateComponentParams: WithoutGridCommon<IDateParams>, eParent: HTMLElement, onReady?: (comp: DateCompWrapper) => void);
+    destroy(): void;
+    getDate(): Date | null;
+    setDate(value: Date | null): void;
+    setDisabled(disabled: boolean): void;
+    setDisplayed(displayed: boolean): void;
+    setInputPlaceholder(placeholder: string): void;
+    setInputAriaLabel(label: string): void;
+    afterGuiAttached(params?: IAfterGuiAttachedParams): void;
+    updateParams(params: IDateParams): void;
+}