ag-grid-community 32.3.2 → 33.0.0

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

@@ -0,0 +1,43 @@
+import type { IAfterGuiAttachedParams } from '../../../interfaces/iAfterGuiAttachedParams';
+import type { FILTER_LOCALE_TEXT } from '../../filterLocaleText';
+import type { Comparator } from '../iScalarFilter';
+import type { ISimpleFilterModel, Tuple } from '../iSimpleFilter';
+import { ScalarFilter } from '../scalarFilter';
+import { DateCompWrapper } from './dateCompWrapper';
+import type { DateFilterModel, DateFilterParams } from './iDateFilter';
+export declare class DateFilter extends ScalarFilter<DateFilterModel, Date, DateCompWrapper> {
+    private readonly eConditionPanelsFrom;
+    private readonly eConditionPanelsTo;
+    private readonly dateConditionFromComps;
+    private readonly dateConditionToComps;
+    private dateFilterParams;
+    private minValidYear;
+    private maxValidYear;
+    private minValidDate;
+    private maxValidDate;
+    private filterModelFormatter;
+    protected filterType: "date";
+    constructor();
+    afterGuiAttached(params?: IAfterGuiAttachedParams): void;
+    protected mapValuesFromModel(filterModel: DateFilterModel | null): Tuple<Date>;
+    protected comparator(): Comparator<Date>;
+    protected setParams(params: DateFilterParams): void;
+    createDateCompWrapper(element: HTMLElement): DateCompWrapper;
+    protected setElementValue(element: DateCompWrapper, value: Date | null): void;
+    protected setElementDisplayed(element: DateCompWrapper, displayed: boolean): void;
+    protected setElementDisabled(element: DateCompWrapper, disabled: boolean): void;
+    protected getDefaultFilterOptions(): string[];
+    protected createValueElement(): HTMLElement;
+    private createFromToElement;
+    protected removeValueElements(startPosition: number, deleteCount?: number): void;
+    protected removeDateComps(components: DateCompWrapper[], startPosition: number, deleteCount?: number): void;
+    private isValidDateValue;
+    protected isConditionUiComplete(position: number): boolean;
+    protected areSimpleModelsEqual(aSimple: DateFilterModel, bSimple: DateFilterModel): boolean;
+    protected createCondition(position: number): DateFilterModel;
+    protected resetPlaceholder(): void;
+    protected getInputs(position: number): Tuple<DateCompWrapper>;
+    protected getValues(position: number): Tuple<Date>;
+    protected translate(key: keyof typeof FILTER_LOCALE_TEXT): string;
+    getModelAsString(model: ISimpleFilterModel): string;
+}

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

@@ -0,0 +1,14 @@
+import type { IFilterOptionDef } from '../../../interfaces/iFilter';
+import type { LocaleTextFunc } from '../../../misc/locale/localeUtils';
+import type { OptionsFactory } from '../optionsFactory';
+import { SimpleFilterModelFormatter } from '../simpleFilterModelFormatter';
+import type { DateFilterModel, DateFilterParams } from './iDateFilter';
+export declare class DateFilterModelFormatter extends SimpleFilterModelFormatter {
+    private dateFilterParams;
+    constructor(dateFilterParams: DateFilterParams, getLocaleTextFunc: () => LocaleTextFunc, optionsFactory: OptionsFactory);
+    protected conditionToString(condition: DateFilterModel, options?: IFilterOptionDef): string;
+    updateParams(params: {
+        dateFilterParams: DateFilterParams;
+        optionsFactory: OptionsFactory;
+    }): void;
+}

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

@@ -0,0 +1,24 @@
+import type { FilterChangedEvent } from '../../../events';
+import type { IFloatingFilterParams } from '../../floating/floatingFilter';
+import { SimpleFloatingFilter } from '../../floating/provided/simpleFloatingFilter';
+import type { ISimpleFilterModel } from '../iSimpleFilter';
+import type { DateFilter } from './dateFilter';
+import { DateFilterModelFormatter } from './dateFilterModelFormatter';
+export declare class DateFloatingFilter extends SimpleFloatingFilter {
+    private readonly eReadOnlyText;
+    private readonly eDateWrapper;
+    private dateComp;
+    private params;
+    private filterParams;
+    protected filterModelFormatter: DateFilterModelFormatter;
+    constructor();
+    protected getDefaultOptions(): string[];
+    init(params: IFloatingFilterParams<DateFilter>): void;
+    refresh(params: IFloatingFilterParams<DateFilter>): void;
+    private updateCompOnModelChange;
+    protected setEditable(editable: boolean): void;
+    onParentModelChanged(model: ISimpleFilterModel, event: FilterChangedEvent): void;
+    private onDateChanged;
+    private getDateComponentParams;
+    private createDateComponent;
+}

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

@@ -0,0 +1,23 @@
+import type { IDateComp, IDateParams } from '../../../interfaces/dateComponent';
+import type { IAfterGuiAttachedParams } from '../../../interfaces/iAfterGuiAttachedParams';
+import { Component } from '../../../widgets/component';
+export declare class DefaultDateComponent extends Component implements IDateComp {
+    private readonly eDateInput;
+    constructor();
+    private params;
+    private usingSafariDatePicker;
+    private isApply;
+    private applyOnFocusOut;
+    init(params: IDateParams): void;
+    private handleInput;
+    private handleFocusOut;
+    private setParams;
+    refresh(params: IDateParams): void;
+    getDate(): Date | null;
+    setDate(date: Date): void;
+    setInputPlaceholder(placeholder: string): void;
+    setInputAriaLabel(ariaLabel: string): void;
+    setDisabled(disabled: boolean): void;
+    afterGuiAttached(params?: IAfterGuiAttachedParams): void;
+    private shouldUseBrowserDatePicker;
+}

package/dist/types/src/filter/provided/number/numberFilter.d.ts

@@ -0,0 +1,32 @@
+import { AgInputNumberField } from '../../../widgets/agInputNumberField';
+import { AgInputTextField } from '../../../widgets/agInputTextField';
+import type { Comparator } from '../iScalarFilter';
+import type { ISimpleFilterModel, Tuple } from '../iSimpleFilter';
+import { ScalarFilter } from '../scalarFilter';
+import type { NumberFilterModel, NumberFilterParams } from './iNumberFilter';
+export declare class NumberFilter extends ScalarFilter<NumberFilterModel, number> {
+    private readonly eValuesFrom;
+    private readonly eValuesTo;
+    private numberFilterParams;
+    private filterModelFormatter;
+    protected filterType: "number";
+    constructor();
+    refresh(params: NumberFilterParams): boolean;
+    protected mapValuesFromModel(filterModel: NumberFilterModel | null): Tuple<number>;
+    protected defaultDebounceMs: number;
+    protected comparator(): Comparator<number>;
+    protected setParams(params: NumberFilterParams): void;
+    protected getDefaultFilterOptions(): string[];
+    protected setElementValue(element: AgInputTextField | AgInputNumberField, value: number | null, fromFloatingFilter?: boolean): void;
+    protected createValueElement(): HTMLElement;
+    private createFromToElement;
+    protected removeValueElements(startPosition: number, deleteCount?: number): void;
+    protected getValues(position: number): Tuple<number>;
+    protected areSimpleModelsEqual(aSimple: NumberFilterModel, bSimple: NumberFilterModel): boolean;
+    private processValue;
+    private stringToFloat;
+    protected createCondition(position: number): NumberFilterModel;
+    protected getInputs(position: number): Tuple<AgInputTextField | AgInputNumberField>;
+    getModelAsString(model: ISimpleFilterModel): string;
+    protected hasInvalidInputs(): boolean;
+}

package/dist/types/src/filter/provided/number/numberFloatingFilter.d.ts

@@ -0,0 +1,12 @@
+import type { FloatingFilterInputService } from '../../floating/provided/iFloatingFilterInputService';
+import { TextInputFloatingFilter } from '../../floating/provided/textInputFloatingFilter';
+import type { INumberFloatingFilterParams, NumberFilterModel } from './iNumberFilter';
+import { NumberFilterModelFormatter } from './numberFilterModelFormatter';
+export declare class NumberFloatingFilter extends TextInputFloatingFilter<NumberFilterModel> {
+    protected filterModelFormatter: NumberFilterModelFormatter;
+    private allowedCharPattern;
+    init(params: INumberFloatingFilterParams): void;
+    refresh(params: INumberFloatingFilterParams): void;
+    protected getDefaultOptions(): string[];
+    protected createFloatingFilterInputService(params: INumberFloatingFilterParams): FloatingFilterInputService;
+}

package/dist/types/src/filter/provided/optionsFactory.d.ts

@@ -0,0 +1,13 @@
+import type { IFilterOptionDef } from '../../interfaces/iFilter';
+import type { ScalarFilterParams } from './iScalarFilter';
+export declare class OptionsFactory {
+    protected customFilterOptions: {
+        [name: string]: IFilterOptionDef;
+    };
+    filterOptions: (IFilterOptionDef | string)[];
+    defaultOption: string;
+    init(params: ScalarFilterParams, defaultOptions: string[]): void;
+    private mapCustomOptions;
+    private selectDefaultItem;
+    getCustomOption(name?: string | null): IFilterOptionDef | undefined;
+}

package/dist/types/src/filter/provided/providedFilter.d.ts

@@ -0,0 +1,84 @@
+import type { IAfterGuiAttachedParams } from '../../interfaces/iAfterGuiAttachedParams';
+import type { IDoesFilterPassParams, IFilterComp } from '../../interfaces/iFilter';
+import type { IRowNode } from '../../interfaces/iRowNode';
+import type { AgPromise } from '../../utils/promise';
+import type { ComponentSelector } from '../../widgets/component';
+import { Component } from '../../widgets/component';
+import { FILTER_LOCALE_TEXT } from '../filterLocaleText';
+import type { IProvidedFilter, ProvidedFilterParams } from './iProvidedFilter';
+/**
+ * Contains common logic to all provided filters (apply button, clear button, etc).
+ * All the filters that come with AG Grid extend this class. User filters do not
+ * extend this class.
+ *
+ * @param M type of filter-model managed by the concrete sub-class that extends this type
+ * @param V type of value managed by the concrete sub-class that extends this type
+ */
+export declare abstract class ProvidedFilter<M, V> extends Component implements IProvidedFilter, IFilterComp {
+    private readonly filterNameKey;
+    private params;
+    protected applyActive: boolean;
+    private hidePopup;
+    private onBtApplyDebounce;
+    private debouncePending;
+    private appliedModel;
+    private positionableFeature;
+    protected readonly eFilterBody: HTMLElement;
+    private eButtonsPanel;
+    private buttonListeners;
+    constructor(filterNameKey: keyof typeof FILTER_LOCALE_TEXT);
+    abstract doesFilterPass(params: IDoesFilterPassParams): boolean;
+    protected abstract updateUiVisibility(): void;
+    protected abstract createBodyTemplate(): string;
+    protected abstract getAgComponents(): ComponentSelector[];
+    protected abstract getCssIdentifier(): string;
+    protected abstract resetUiToDefaults(silent?: boolean): AgPromise<void>;
+    protected abstract setModelIntoUi(model: M): AgPromise<void>;
+    protected abstract areModelsEqual(a: M, b: M): boolean;
+    /** Used to get the filter type for filter models. */
+    protected abstract filterType: string;
+    postConstruct(): void;
+    protected handleKeyDown(e: KeyboardEvent): void;
+    abstract getModelFromUi(): M | null;
+    getFilterTitle(): string;
+    isFilterActive(): boolean;
+    protected resetTemplate(paramsMap?: any): void;
+    protected isReadOnly(): boolean;
+    init(params: ProvidedFilterParams): void;
+    protected setParams(params: ProvidedFilterParams): void;
+    protected updateParams(params: ProvidedFilterParams): void;
+    private resetButtonsPanel;
+    protected defaultDebounceMs: number;
+    private setupOnBtApplyDebounce;
+    private checkApplyDebounce;
+    getModel(): M | null;
+    setModel(model: M | null): AgPromise<void>;
+    private onBtCancel;
+    protected handleCancelEnd(e: Event): void;
+    protected resetUiToActiveModel(currentModel: M | null, afterUiUpdatedFunc?: () => void): void;
+    private onBtClear;
+    private onBtReset;
+    /**
+     * Applies changes made in the UI to the filter, and returns true if the model has changed.
+     */
+    applyModel(source?: 'api' | 'ui' | 'rowDataUpdated'): boolean;
+    protected isModelValid(model: M): boolean;
+    private onFormSubmit;
+    protected onBtApply(afterFloatingFilter?: boolean, afterDataChange?: boolean, e?: Event): void;
+    onNewRowsLoaded(): void;
+    close(e?: Event): void;
+    /**
+     * By default, if the change came from a floating filter it will be applied immediately, otherwise if there is no
+     * apply button it will be applied after a debounce, otherwise it will not be applied at all. This behaviour can
+     * be adjusted by using the apply parameter.
+     */
+    protected onUiChanged(fromFloatingFilter?: boolean, apply?: 'immediately' | 'debounce' | 'prevent'): void;
+    afterGuiAttached(params?: IAfterGuiAttachedParams): void;
+    private refreshFilterResizer;
+    afterGuiDetached(): void;
+    refresh(newParams: ProvidedFilterParams): boolean;
+    destroy(): void;
+    protected translate(key: keyof typeof FILTER_LOCALE_TEXT): string;
+    protected getCellValue(rowNode: IRowNode): V | null | undefined;
+    protected getPositionableElement(): HTMLElement;
+}

package/dist/types/src/filter/provided/simpleFilter.d.ts

@@ -0,0 +1,106 @@
+import type { IAfterGuiAttachedParams } from '../../interfaces/iAfterGuiAttachedParams';
+import type { IDoesFilterPassParams } from '../../interfaces/iFilter';
+import { AgPromise } from '../../utils/promise';
+import type { AgInputTextField } from '../../widgets/agInputTextField';
+import { AgRadioButton } from '../../widgets/agRadioButton';
+import { AgSelect } from '../../widgets/agSelect';
+import type { ComponentSelector } from '../../widgets/component';
+import { Component } from '../../widgets/component';
+import type { ICombinedSimpleModel, ISimpleFilter, ISimpleFilterModel, ISimpleFilterModelType, JoinOperator, SimpleFilterParams, Tuple } from './iSimpleFilter';
+import { OptionsFactory } from './optionsFactory';
+import { ProvidedFilter } from './providedFilter';
+/**
+ * Every filter with a dropdown where the user can specify a comparing type against the filter values.
+ *
+ * @param M type of filter-model managed by the concrete sub-class that extends this type
+ * @param V type of value managed by the concrete sub-class that extends this type
+ * @param E type of UI element used for collecting user-input
+ */
+export declare abstract class SimpleFilter<M extends ISimpleFilterModel, V, E = AgInputTextField> extends ProvidedFilter<M | ICombinedSimpleModel<M>, V> implements ISimpleFilter {
+    protected readonly eTypes: AgSelect[];
+    protected readonly eJoinOperatorPanels: HTMLElement[];
+    protected readonly eJoinOperatorsAnd: AgRadioButton[];
+    protected readonly eJoinOperatorsOr: AgRadioButton[];
+    protected readonly eConditionBodies: HTMLElement[];
+    private readonly listener;
+    private maxNumConditions;
+    private numAlwaysVisibleConditions;
+    private defaultJoinOperator;
+    private filterPlaceholder;
+    private lastUiCompletePosition;
+    private joinOperatorId;
+    private filterListOptions;
+    protected optionsFactory: OptionsFactory;
+    protected abstract getDefaultFilterOptions(): string[];
+    protected abstract createValueElement(): HTMLElement;
+    protected abstract removeValueElements(startPosition: number, deleteCount?: number): void;
+    protected abstract areSimpleModelsEqual(a: ISimpleFilterModel, b: ISimpleFilterModel): boolean;
+    protected abstract createCondition(position: number): M;
+    protected abstract mapValuesFromModel(filterModel: ISimpleFilterModel | null): Tuple<V>;
+    protected abstract evaluateNullValue(filterType?: ISimpleFilterModelType | null): boolean;
+    protected abstract evaluateNonNullValue(range: Tuple<V>, cellValue: V, filterModel: M, params: IDoesFilterPassParams): boolean;
+    protected abstract getInputs(position: number): Tuple<E>;
+    protected abstract getValues(position: number): Tuple<V>;
+    protected getNumberOfInputs(type?: ISimpleFilterModelType | null): number;
+    onFloatingFilterChanged(type: string | null | undefined, value: V | null): void;
+    private setTypeFromFloatingFilter;
+    getModelFromUi(): M | ICombinedSimpleModel<M> | null;
+    protected getConditionTypes(): (ISimpleFilterModelType | null)[];
+    protected getConditionType(position: number): ISimpleFilterModelType | null;
+    protected getJoinOperator(): JoinOperator;
+    protected areModelsEqual(a: M | ICombinedSimpleModel<M>, b: M | ICombinedSimpleModel<M>): boolean;
+    private shouldRefresh;
+    refresh(newParams: SimpleFilterParams): boolean;
+    protected setModelIntoUi(model: ISimpleFilterModel | ICombinedSimpleModel<M>): AgPromise<void>;
+    doesFilterPass(params: IDoesFilterPassParams): boolean;
+    protected setParams(params: SimpleFilterParams): void;
+    private setNumConditions;
+    private createOption;
+    private createJoinOperatorPanel;
+    private createJoinOperator;
+    private createFilterListOptions;
+    private putOptionsIntoDropdown;
+    private createBoilerplateListOption;
+    private createCustomListOption;
+    protected createBodyTemplate(): string;
+    protected getAgComponents(): ComponentSelector[];
+    protected getCssIdentifier(): string;
+    protected updateUiVisibility(): void;
+    private updateNumConditions;
+    private updateConditionStatusesAndValues;
+    private shouldAddNewConditionAtEnd;
+    private removeConditionsAndOperators;
+    private removeElements;
+    protected removeComponents<TEventType extends string>(components: Component<TEventType>[], startPosition: number, deleteCount?: number): void;
+    afterGuiAttached(params?: IAfterGuiAttachedParams): void;
+    afterGuiDetached(): void;
+    private getPlaceholderText;
+    protected resetPlaceholder(): void;
+    protected setElementValue(element: E, value: V | null, fromFloatingFilter?: boolean): void;
+    protected setElementDisplayed(element: E, displayed: boolean): void;
+    protected setElementDisabled(element: E, disabled: boolean): void;
+    protected attachElementOnChange(element: E, listener: () => void): void;
+    protected forEachInput(cb: (element: E, index: number, position: number, numberOfInputs: number) => void): void;
+    protected forEachPositionInput(position: number, cb: (element: E, index: number, position: number, numberOfInputs: number) => void): void;
+    private forEachPositionTypeInput;
+    private isConditionDisabled;
+    private isConditionBodyVisible;
+    protected isConditionUiComplete(position: number): boolean;
+    private getNumConditions;
+    private getUiCompleteConditions;
+    private createMissingConditionsAndOperators;
+    protected resetUiToDefaults(silent?: boolean): AgPromise<void>;
+    private resetType;
+    private resetJoinOperatorAnd;
+    private resetJoinOperatorOr;
+    private resetJoinOperator;
+    private updateJoinOperatorsDisabled;
+    private updateJoinOperatorDisabled;
+    private resetInput;
+    private setConditionIntoUi;
+    private setValueFromFloatingFilter;
+    private addChangedListeners;
+    /** returns true if the row passes the said condition */
+    protected individualConditionPasses(params: IDoesFilterPassParams, filterModel: M): boolean;
+    protected hasInvalidInputs(): boolean;
+}

package/dist/types/src/filter/provided/simpleFilterModelFormatter.d.ts

@@ -0,0 +1,16 @@
+import type { IFilterOptionDef, ProvidedFilterModel } from '../../interfaces/iFilter';
+import type { LocaleTextFunc } from '../../misc/locale/localeUtils';
+import type { ISimpleFilterModel } from './iSimpleFilter';
+import type { OptionsFactory } from './optionsFactory';
+export declare abstract class SimpleFilterModelFormatter<TValue = any> {
+    private readonly getLocaleTextFunc;
+    private optionsFactory;
+    protected readonly valueFormatter?: ((value: TValue | null) => string | null) | undefined;
+    constructor(getLocaleTextFunc: () => LocaleTextFunc, optionsFactory: OptionsFactory, valueFormatter?: ((value: TValue | null) => string | null) | undefined);
+    getModelAsString(model: ISimpleFilterModel | null): string | null;
+    protected abstract conditionToString(condition: ProvidedFilterModel, opts?: IFilterOptionDef): string;
+    updateParams(params: {
+        optionsFactory: OptionsFactory;
+    }): void;
+    protected formatValue(value?: TValue | null): string;
+}

package/dist/types/src/filter/provided/simpleFilterUtils.d.ts

@@ -0,0 +1,7 @@
+import type { IFilterOptionDef } from '../../interfaces/iFilter';
+import type { JoinOperator, Tuple } from './iSimpleFilter';
+export declare function removeItems<T>(items: T[], startPosition: number, deleteCount?: number): T[];
+export declare function isBlank<V>(cellValue: V): boolean;
+export declare function getDefaultJoinOperator(defaultJoinOperator?: JoinOperator): JoinOperator;
+export declare function evaluateCustomFilter<V>(customFilterOption: IFilterOptionDef | undefined, values: Tuple<V>, cellValue: V | null | undefined): boolean | undefined;
+export declare function validateAndUpdateConditions<M>(conditions: M[], maxNumConditions: number): number;

package/dist/types/src/filter/provided/text/textFilter.d.ts

@@ -0,0 +1,33 @@
+import type { IDoesFilterPassParams } from '../../../interfaces/iFilter';
+import { AgInputTextField } from '../../../widgets/agInputTextField';
+import type { ISimpleFilterModel, ISimpleFilterModelType, Tuple } from '../iSimpleFilter';
+import { SimpleFilter } from '../simpleFilter';
+import type { TextFilterModel, TextFilterParams } from './iTextFilter';
+export declare class TextFilter extends SimpleFilter<TextFilterModel, string> {
+    protected filterType: "text";
+    private readonly defaultFormatter;
+    private readonly defaultLowercaseFormatter;
+    private readonly defaultMatcher;
+    private readonly eValuesFrom;
+    private readonly eValuesTo;
+    private matcher;
+    private formatter;
+    private textFilterParams;
+    private filterModelFormatter;
+    constructor();
+    protected defaultDebounceMs: number;
+    protected setParams(params: TextFilterParams): void;
+    protected createCondition(position: number): TextFilterModel;
+    protected areSimpleModelsEqual(aSimple: TextFilterModel, bSimple: TextFilterModel): boolean;
+    protected getInputs(position: number): Tuple<AgInputTextField>;
+    protected getValues(position: number): Tuple<string>;
+    private getValuesWithSideEffects;
+    protected getDefaultFilterOptions(): string[];
+    protected createValueElement(): HTMLElement;
+    private createFromToElement;
+    protected removeValueElements(startPosition: number, deleteCount?: number): void;
+    protected mapValuesFromModel(filterModel: TextFilterModel | null): Tuple<string>;
+    protected evaluateNullValue(filterType: ISimpleFilterModelType | null): boolean;
+    protected evaluateNonNullValue(values: Tuple<string>, cellValue: string, filterModel: TextFilterModel, params: IDoesFilterPassParams): boolean;
+    getModelAsString(model: ISimpleFilterModel): string;
+}

package/dist/types/src/filter/provided/text/textFloatingFilter.d.ts

@@ -0,0 +1,11 @@
+import type { FloatingFilterInputService } from '../../floating/provided/iFloatingFilterInputService';
+import { TextInputFloatingFilter } from '../../floating/provided/textInputFloatingFilter';
+import type { SimpleFilterModelFormatter } from '../simpleFilterModelFormatter';
+import type { ITextFloatingFilterParams, TextFilterModel } from './iTextFilter';
+export declare class TextFloatingFilter extends TextInputFloatingFilter<TextFilterModel> {
+    protected filterModelFormatter: SimpleFilterModelFormatter;
+    init(params: ITextFloatingFilterParams): void;
+    refresh(params: ITextFloatingFilterParams): void;
+    protected getDefaultOptions(): string[];
+    protected createFloatingFilterInputService(): FloatingFilterInputService;
+}

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

@@ -0,0 +1,28 @@
+import type { NamedBean } from '../context/bean';
+import { BeanStub } from '../context/beanStub';
+import type { RowNode } from '../entities/rowNode';
+export type QuickFilterServiceEvent = 'quickFilterChanged';
+export declare class QuickFilterService extends BeanStub<QuickFilterServiceEvent> implements NamedBean {
+    beanName: "quickFilter";
+    private colsToUse;
+    private quickFilter;
+    private quickFilterParts;
+    private parser?;
+    private matcher?;
+    postConstruct(): void;
+    refreshCols(): void;
+    isFilterPresent(): boolean;
+    doesRowPass(node: RowNode): boolean;
+    resetCache(): void;
+    private setFilterParts;
+    private parseFilter;
+    private setFilter;
+    private setParserAndMatcher;
+    private onColumnConfigChanged;
+    private doesRowPassNoCache;
+    private doesRowPassCache;
+    private doesRowPassMatcher;
+    private checkGenerateAggText;
+    private getTextForColumn;
+    private getAggText;
+}

package/dist/types/src/focusService.d.ts

@@ -0,0 +1,72 @@
+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 { RowNode } from './entities/rowNode';
+import type { CellFocusedParams } from './events';
+import type { HeaderCellCtrl } from './headerRendering/cells/column/headerCellCtrl';
+import type { TabToNextHeaderParams } from './interfaces/iCallbackParams';
+import type { CellPosition } from './interfaces/iCellPosition';
+import type { WithoutGridCommon } from './interfaces/iCommon';
+import type { HeaderPosition } from './interfaces/iHeaderPosition';
+import type { RowPinnedType } from './interfaces/iRowNode';
+export declare class FocusService extends BeanStub implements NamedBean {
+    beanName: "focusSvc";
+    private colModel;
+    private visibleCols;
+    private rowRenderer;
+    private navigation?;
+    private filterManager?;
+    private overlays?;
+    wireBeans(beans: BeanCollection): void;
+    private focusedCell;
+    private restoredFocusedCell;
+    focusedHeader: HeaderPosition | null;
+    /** the column that had focus before it moved into the advanced filter */
+    private advFilterFocusColumn;
+    private awaitRestoreFocusedCell;
+    postConstruct(): void;
+    onColumnEverythingChanged(): void;
+    getFocusCellToUseAfterRefresh(): CellPosition | null;
+    getFocusHeaderToUseAfterRefresh(): HeaderPosition | null;
+    private isDomDataMissingInHierarchy;
+    getFocusedCell(): CellPosition | null;
+    shouldRestoreFocus(cell: CellPosition): boolean;
+    clearRestoreFocus(): void;
+    restoreFocusedCell(cellPosition: CellPosition, setFocusCallback: () => void): void;
+    private isCellRestoreFocused;
+    setRestoreFocusedCell(cellPosition: CellPosition): void;
+    private getFocusEventParams;
+    clearFocusedCell(): void;
+    setFocusedCell(params: CellFocusedParams): void;
+    isCellFocused(cellPosition: CellPosition): boolean;
+    isRowNodeFocused(rowNode: RowNode): boolean;
+    isHeaderWrapperFocused(headerCtrl: HeaderCellCtrl): boolean;
+    focusHeaderPosition(params: {
+        headerPosition: HeaderPosition | null;
+        direction?: 'Before' | 'After' | null;
+        fromTab?: boolean;
+        allowUserOverride?: boolean;
+        event?: KeyboardEvent;
+        fromCell?: boolean;
+        rowWithoutSpanValue?: number;
+    }): boolean;
+    focusHeaderPositionFromUserFunc(params: {
+        userFunc: (params: WithoutGridCommon<TabToNextHeaderParams>) => boolean | HeaderPosition;
+        headerPosition: HeaderPosition | null;
+        direction?: 'Before' | 'After' | null;
+        event?: KeyboardEvent;
+    }): boolean;
+    private getHeaderPositionFromUserFunc;
+    private focusProvidedHeaderPosition;
+    focusFirstHeader(): boolean;
+    focusLastHeader(event?: KeyboardEvent): boolean;
+    focusPreviousFromFirstCell(event?: KeyboardEvent): boolean;
+    isAnyCellFocused(): boolean;
+    isRowFocused(rowIndex: number, rowPinnedType: RowPinnedType): boolean;
+    focusOverlay(backwards?: boolean): boolean;
+    focusGridView(column?: AgColumn, backwards?: boolean, canFocusOverlay?: boolean): boolean;
+    private focusAdvancedFilter;
+    focusNextFromAdvancedFilter(backwards?: boolean, forceFirstColumn?: boolean): boolean;
+    clearAdvancedFilterColumn(): void;
+}

package/dist/types/src/grid.d.ts

@@ -0,0 +1,54 @@
+import type { GridApi } from './api/gridApi';
+import { Context } from './context/context';
+import type { GridOptions } from './entities/gridOptions';
+import type { IFrameworkOverrides } from './interfaces/iFrameworkOverrides';
+import type { Module } from './interfaces/iModule';
+export interface GridParams {
+    globalListener?: (...args: any[]) => any;
+    globalSyncListener?: (...args: any[]) => any;
+    frameworkOverrides?: IFrameworkOverrides;
+    providedBeanInstances?: {
+        [key: string]: any;
+    };
+    setThemeOnGridDiv?: boolean;
+    /**
+     * Modules to be registered directly with this grid instance.
+     */
+    modules?: Module[];
+}
+export interface Params {
+    /**
+     * Modules to be registered directly with this grid instance.
+     */
+    modules?: Module[];
+}
+/**
+ * When providing global grid options, specify how they should be merged with the grid options provided to individual grids.
+ * - `deep` will merge the global options into the provided options deeply, with provided options taking precedence.
+ * - `shallow` will merge the global options with the provided options shallowly, with provided options taking precedence.
+ * @default 'shallow'
+ * @param gridOptions - global grid options
+ */
+export type GlobalGridOptionsMergeStrategy = 'deep' | 'shallow';
+/**
+ * Provide gridOptions that will be shared by all grid instances.
+ * Individually defined GridOptions will take precedence over global options.
+ * @param gridOptions - global grid options
+ */
+export declare function provideGlobalGridOptions(gridOptions: GridOptions, mergeStrategy?: GlobalGridOptionsMergeStrategy): void;
+export declare function _getGlobalGridOption<K extends keyof GridOptions>(gridOption: K): GridOptions[K];
+/**
+ * Creates a grid inside the provided HTML element.
+ * @param eGridDiv Parent element to contain the grid.
+ * @param gridOptions Configuration for the grid.
+ * @param params Individually register AG Grid Modules to this grid.
+ * @returns api to be used to interact with the grid.
+ */
+export declare function createGrid<TData>(eGridDiv: HTMLElement, gridOptions: GridOptions<TData>, params?: Params): GridApi<TData>;
+export declare class GridCoreCreator {
+    create(eGridDiv: HTMLElement, providedOptions: GridOptions, createUi: (context: Context) => void, acceptChanges?: (context: Context) => void, params?: GridParams, destroyCallback?: () => void): GridApi;
+    private getRegisteredModules;
+    private registerModuleFeatures;
+    private createProvidedBeans;
+    private createBeansList;
+}

package/dist/types/src/gridBodyComp/abstractFakeScrollComp.d.ts

@@ -0,0 +1,21 @@
+import { Component } from '../widgets/component';
+import type { ScrollPartner } from './gridBodyScrollFeature';
+export declare abstract class AbstractFakeScrollComp extends Component implements ScrollPartner {
+    private readonly direction;
+    readonly eViewport: HTMLElement;
+    protected readonly eContainer: HTMLElement;
+    protected invisibleScrollbar: boolean;
+    protected hideTimeout: number;
+    protected abstract setScrollVisible(): void;
+    abstract getScrollPosition(): number;
+    abstract setScrollPosition(value: number): void;
+    constructor(template: string, direction: 'horizontal' | 'vertical');
+    postConstruct(): void;
+    destroy(): void;
+    protected initialiseInvisibleScrollbar(): void;
+    protected addActiveListenerToggles(): void;
+    protected onScrollVisibilityChanged(): void;
+    protected hideAndShowInvisibleScrollAsNeeded(): void;
+    protected attemptSettingScrollPosition(value: number): void;
+    onScrollCallback(fn: () => void): void;
+}

package/dist/types/src/gridBodyComp/centerWidthFeature.d.ts

@@ -0,0 +1,8 @@
+import { BeanStub } from '../context/beanStub';
+export declare class CenterWidthFeature extends BeanStub {
+    private readonly callback;
+    private readonly addSpacer;
+    constructor(callback: (width: number) => void, addSpacer?: boolean);
+    postConstruct(): void;
+    private setWidth;
+}

package/dist/types/src/gridBodyComp/fakeHScrollComp.d.ts

@@ -0,0 +1,23 @@
+import type { BeanCollection } from '../context/context';
+import type { ComponentSelector } from '../widgets/component';
+import { AbstractFakeScrollComp } from './abstractFakeScrollComp';
+export declare class FakeHScrollComp extends AbstractFakeScrollComp {
+    private visibleCols;
+    private scrollVisibleSvc;
+    wireBeans(beans: BeanCollection): void;
+    private readonly eLeftSpacer;
+    private readonly eRightSpacer;
+    private enableRtl;
+    constructor();
+    postConstruct(): void;
+    destroy(): void;
+    protected initialiseInvisibleScrollbar(): void;
+    private refreshCompBottom;
+    protected onScrollVisibilityChanged(): void;
+    private setFakeHScrollSpacerWidths;
+    private setScrollVisibleDebounce;
+    protected setScrollVisible(): void;
+    getScrollPosition(): number;
+    setScrollPosition(value: number): void;
+}
+export declare const FakeHScrollSelector: ComponentSelector;