ag-grid-community 32.3.2 → 33.0.0

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

@@ -1,13 +0,0 @@
-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;
-/** @deprecated v31.1 */
-export declare function getFilterInstance<TFilter extends IFilter>(beans: BeanCollection, key: string | Column, callback?: (filter: TFilter | null) => void): undefined;
-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/core/filter/columnFilterService.d.ts

@@ -1,91 +0,0 @@
-import type { UserCompDetails } from '../components/framework/userComponentFactory';
-import { BeanStub } from '../context/beanStub';
-import type { BeanCollection, 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 { FilterChangedEventSourceType } from '../events';
-import type { FilterModel, IFilter, IFilterComp, IFilterParams } from '../interfaces/iFilter';
-import { AgPromise } from '../utils/promise';
-export declare class ColumnFilterService extends BeanStub {
-    beanName: BeanName;
-    private valueService;
-    private columnModel;
-    private rowModel;
-    private userComponentFactory;
-    private rowRenderer;
-    private dataTypeService?;
-    private filterManager?;
-    wireBeans(beans: BeanCollection): void;
-    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;
-    private setModelOnFilterWrapper;
-    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 createValueGetter;
-    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;
-    getFilterInstance<TFilter extends IFilter>(key: string | AgColumn, callback?: (filter: TFilter | null) => void): undefined;
-    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;
-    destroy(): void;
-}
-export interface FilterWrapper {
-    compiledElement: any;
-    column: AgColumn;
-    filterPromise: AgPromise<IFilterComp> | null;
-    filter?: IFilterComp;
-    compDetails: UserCompDetails | null;
-}

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

@@ -1,85 +0,0 @@
-import type { UserCompDetails } from '../components/framework/userComponentFactory';
-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 { FilterWrapper } from './columnFilterService';
-export declare class FilterManager extends BeanStub implements NamedBean {
-    beanName: "filterManager";
-    private columnModel;
-    private dataTypeService?;
-    private quickFilterService?;
-    private advancedFilterService;
-    private columnFilterService?;
-    wireBeans(beans: BeanCollection): void;
-    private externalFilterPresent;
-    private aggFiltering;
-    private advancedFilterModelUpdateQueue;
-    postConstruct(): void;
-    private isExternalFilterPresentCallback;
-    private doesExternalFilterPass;
-    setFilterModel(model: FilterModel | null, source?: FilterChangedEventSourceType): void;
-    getFilterModel(): FilterModel;
-    isColumnFilterPresent(): boolean;
-    isAggregateFilterPresent(): boolean;
-    isExternalFilterPresent(): boolean;
-    isChildFilterPresent(): boolean;
-    private isAdvancedFilterPresent;
-    private onAdvancedFilterEnabledChanged;
-    isAdvancedFilterEnabled(): boolean;
-    isAdvancedFilterHeaderActive(): boolean;
-    isAnyFilterPresent(): 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;
-    getAdvancedFilterModel(): AdvancedFilterModel | null;
-    setAdvancedFilterModel(expression: AdvancedFilterModel | null | undefined): void;
-    toggleAdvancedFilterBuilder(show: boolean, source: 'api' | 'ui'): void;
-    private updateAdvancedFilterColumns;
-    hasFloatingFilters(): boolean;
-    getFilterInstance<TFilter extends IFilter>(key: string | AgColumn, callback?: (filter: TFilter | null) => void): undefined;
-    getColumnFilterInstance<TFilter extends IFilter>(key: string | AgColumn): Promise<TFilter | null | undefined>;
-    private warnAdvancedFilters;
-    setupAdvancedFilterHeaderComp(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/core/filter/filterModule.d.ts

@@ -1,13 +0,0 @@
-export declare const FilterCoreModule: import("../interfaces/iModule").Module;
-export declare const FilterApiModule: import("../interfaces/iModule").Module;
-export declare const ColumnFilterModule: import("../interfaces/iModule").Module;
-export declare const ColumnFilterApiModule: import("../interfaces/iModule").Module;
-export declare const FloatingFilterCoreModule: import("../interfaces/iModule").Module;
-export declare const FloatingFilterModule: import("../interfaces/iModule").Module;
-export declare const ReadOnlyFloatingFilterModule: import("../interfaces/iModule").Module;
-export declare const SimpleFilterModule: import("../interfaces/iModule").Module;
-export declare const SimpleFloatingFilterModule: import("../interfaces/iModule").Module;
-export declare const QuickFilterCoreModule: import("../interfaces/iModule").Module;
-export declare const QuickFilterApiModule: import("../interfaces/iModule").Module;
-export declare const QuickFilterModule: import("../interfaces/iModule").Module;
-export declare const FilterModule: import("../interfaces/iModule").Module;

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

@@ -1,25 +0,0 @@
-import type { BeanCollection } from '../context/context';
-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 filterManager?;
-    private columnModel;
-    wireBeans(beans: BeanCollection): void;
-    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/core/filter/floating/floatingFilter.d.ts

@@ -1,80 +0,0 @@
-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;
-    /** @deprecated v31.1 Use `colDef.suppressFloatingFilterButton` instead. */
-    suppressFilterButton: boolean;
-    /**
-     * 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;
-    /** @deprecated v31.1 - Use `refresh` instead */
-    onParamsUpdated?(params: IFloatingFilterParams<P>): 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/core/filter/floating/floatingFilterMapper.d.ts

@@ -1,3 +0,0 @@
-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/core/filter/floating/provided/floatingFilterTextInputService.d.ts

@@ -1,22 +0,0 @@
-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 eFloatingFilterTextInput;
-    private valueChangedListener;
-    constructor(params?: {
-        config?: AgInputTextFieldParams | undefined;
-    } | undefined);
-    setupGui(parentElement: HTMLElement): void;
-    setEditable(editable: boolean): void;
-    setAutoComplete(autoComplete: boolean | string): void;
-    getValue(): string | null | undefined;
-    setValue(value: string | null | undefined, silent?: boolean): void;
-    setValueChangedListener(listener: (e: KeyboardEvent) => void): void;
-    setParams(params: {
-        ariaLabel: string;
-        autoComplete?: boolean | string;
-    }): void;
-    private setAriaLabel;
-}

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

@@ -1,16 +0,0 @@
-import type { BeanCollection } from '../../../context/context';
-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 columnNameService;
-    wireBeans(beans: BeanCollection): void;
-    private readonly eFloatingFilterText;
-    private params;
-    constructor();
-    destroy(): void;
-    init(params: IFloatingFilterParams): void;
-    onParentModelChanged(parentModel: any): void;
-    onParamsUpdated(params: IFloatingFilterParams): void;
-    refresh(params: IFloatingFilterParams): void;
-}

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

@@ -1,34 +0,0 @@
-import type { BeanCollection } from '../../../context/context';
-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> {
-    private columnNameService;
-    wireBeans(beans: BeanCollection): void;
-    abstract onParentModelChanged(model: ProvidedFilterModel, event: FilterChangedEvent): void;
-    protected abstract getDefaultFilterOptions(): string[];
-    protected abstract setEditable(editable: boolean): void;
-    protected abstract getFilterModelFormatter(): SimpleFilterModelFormatter;
-    private lastType;
-    protected optionsFactory: OptionsFactory;
-    private readOnly;
-    protected getDefaultDebounceMs(): number;
-    destroy(): void;
-    protected isEventFromFloatingFilter(event: FilterChangedEvent): boolean | undefined;
-    protected isEventFromDataChange(event: FilterChangedEvent): boolean | undefined;
-    protected getLastType(): string | null | undefined;
-    protected isReadOnly(): boolean;
-    protected setLastTypeFromModel(model: ProvidedFilterModel): void;
-    protected canWeEditAfterModelFromParentFilter(model: ProvidedFilterModel): boolean;
-    init(params: IFloatingFilterParams): void;
-    private setSimpleParams;
-    onParamsUpdated(params: IFloatingFilterParams): void;
-    refresh(params: IFloatingFilterParams): void;
-    private doesFilterHaveSingleInput;
-    private isTypeEditable;
-    protected getAriaLabel(params: IFloatingFilterParams): string;
-}

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

@@ -1,25 +0,0 @@
-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 floatingFilterInputService;
-    protected params: ITextInputFloatingFilterParams;
-    private applyActive;
-    protected abstract createFloatingFilterInputService(params: ITextInputFloatingFilterParams): FloatingFilterInputService;
-    postConstruct(): void;
-    protected getDefaultDebounceMs(): number;
-    onParentModelChanged(model: M, event: FilterChangedEvent): void;
-    init(params: ITextInputFloatingFilterParams): void;
-    private setupFloatingFilterInputService;
-    private setTextInputParams;
-    onParamsUpdated(params: ITextInputFloatingFilterParams): void;
-    refresh(params: ITextInputFloatingFilterParams): void;
-    protected recreateFloatingFilterInputService(params: ITextInputFloatingFilterParams): void;
-    private syncUpWithParentFilter;
-    protected setEditable(editable: boolean): void;
-}
-export {};

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

@@ -1,26 +0,0 @@
-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, userComponentFactory: 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;
-    private setDateCompDisabled;
-}

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

@@ -1,48 +0,0 @@
-import type { BeanCollection } from '../../../context/context';
-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 userComponentFactory;
-    private context;
-    wireBeans(beans: BeanCollection): void;
-    private readonly eConditionPanelsFrom;
-    private readonly eConditionPanelsTo;
-    private readonly dateConditionFromComps;
-    private readonly dateConditionToComps;
-    private dateFilterParams;
-    private minValidYear;
-    private maxValidYear;
-    private minValidDate;
-    private maxValidDate;
-    private filterModelFormatter;
-    constructor();
-    afterGuiAttached(params?: IAfterGuiAttachedParams): void;
-    protected mapValuesFromModel(filterModel: DateFilterModel | null): Tuple<Date>;
-    protected comparator(): Comparator<Date>;
-    private defaultComparator;
-    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 getFilterType(): 'date';
-    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/core/filter/provided/date/dateFilterModelFormatter.d.ts

@@ -1,14 +0,0 @@
-import type { IFilterOptionDef } from '../../../interfaces/iFilter';
-import type { LocaleService } from '../../../localeService';
-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, localeService: LocaleService, optionsFactory: OptionsFactory);
-    protected conditionToString(condition: DateFilterModel, options?: IFilterOptionDef): string;
-    updateParams(params: {
-        dateFilterParams: DateFilterParams;
-        optionsFactory: OptionsFactory;
-    }): void;
-}

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

@@ -1,31 +0,0 @@
-import type { BeanCollection } from '../../../context/context';
-import type { FilterChangedEvent } from '../../../events';
-import type { IFloatingFilterParams } from '../../floating/floatingFilter';
-import { SimpleFloatingFilter } from '../../floating/provided/simpleFloatingFilter';
-import type { ISimpleFilterModel } from '../iSimpleFilter';
-import type { SimpleFilterModelFormatter } from '../simpleFilterModelFormatter';
-import type { DateFilter } from './dateFilter';
-export declare class DateFloatingFilter extends SimpleFloatingFilter {
-    private userComponentFactory;
-    private context;
-    wireBeans(beans: BeanCollection): void;
-    private readonly eReadOnlyText;
-    private readonly eDateWrapper;
-    private dateComp;
-    private params;
-    private filterParams;
-    private filterModelFormatter;
-    constructor();
-    protected getDefaultFilterOptions(): string[];
-    init(params: IFloatingFilterParams<DateFilter>): void;
-    onParamsUpdated(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;
-    private updateDateComponent;
-    protected getFilterModelFormatter(): SimpleFilterModelFormatter;
-}

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

@@ -1,21 +0,0 @@
-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;
-    destroy(): void;
-    init(params: IDateParams): void;
-    private setParams;
-    onParamsUpdated(params: IDateParams): void;
-    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/core/filter/provided/number/numberFilter.d.ts

@@ -1,32 +0,0 @@
-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;
-    constructor();
-    refresh(params: NumberFilterParams): boolean;
-    protected mapValuesFromModel(filterModel: NumberFilterModel | null): Tuple<number>;
-    protected getDefaultDebounceMs(): 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;
-    protected getFilterType(): 'number';
-    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/core/filter/provided/number/numberFloatingFilter.d.ts

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

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

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