ag-grid-enterprise

  • Version 32.0.2
  • Published
  • 23.1 MB
  • 2 dependencies
  • Commercial license

Install

npm i ag-grid-enterprise
yarn add ag-grid-enterprise
pnpm add ag-grid-enterprise

Overview

Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue

Index

Variables

Functions

Classes

Interfaces

Variables

variable AdvancedFilterModule

const AdvancedFilterModule: Module;

    variable agCharts

    const agCharts: { time: any; AgCharts: any };

      variable AgGroupComponentSelector

      const AgGroupComponentSelector: ComponentSelector;

        variable ClipboardModule

        const ClipboardModule: Module;

          variable ColumnsToolPanelModule

          const ColumnsToolPanelModule: Module;

            variable EnterpriseCoreModule

            const EnterpriseCoreModule: Module;

              variable ExcelExportModule

              const ExcelExportModule: Module;

                variable FiltersToolPanelModule

                const FiltersToolPanelModule: Module;

                  variable GridChartsModule

                  const GridChartsModule: Module;

                    variable MasterDetailModule

                    const MasterDetailModule: Module;
                      const MenuModule: Module;

                        variable MultiFilterModule

                        const MultiFilterModule: Module;

                          variable RangeSelectionModule

                          const RangeSelectionModule: Module;

                            variable RichSelectModule

                            const RichSelectModule: Module;

                              variable RowGroupingModule

                              const RowGroupingModule: Module;

                                variable ServerSideRowModelModule

                                const ServerSideRowModelModule: Module;

                                  variable SetFilterModule

                                  const SetFilterModule: Module;

                                    variable SideBarModule

                                    const SideBarModule: Module;

                                      variable SparklinesModule

                                      const SparklinesModule: Module;

                                        variable StatusBarModule

                                        const StatusBarModule: Module;

                                          variable ViewportRowModelModule

                                          const ViewportRowModelModule: Module;

                                            Functions

                                            function exportMultipleSheetsAsExcel

                                            exportMultipleSheetsAsExcel: (params: ExcelExportMultipleSheetParams) => void;

                                              function getMultipleSheetsAsExcel

                                              getMultipleSheetsAsExcel: (
                                              params: ExcelExportMultipleSheetParams
                                              ) => Blob | undefined;

                                                Classes

                                                class AgDialog

                                                class AgDialog extends AgPanel<DialogOptions> implements FocusableContainer {}

                                                  constructor

                                                  constructor(config: DialogOptions);

                                                    method destroy

                                                    destroy: () => void;

                                                      method postConstruct

                                                      postConstruct: () => void;

                                                        method renderComponent

                                                        protected renderComponent: () => void;

                                                          method setAllowFocus

                                                          setAllowFocus: (allowFocus: boolean) => void;

                                                            method setMaximizable

                                                            setMaximizable: (maximizable: boolean) => void;

                                                              method setMovable

                                                              setMovable: (movable: boolean) => void;

                                                                method setResizable

                                                                setResizable: (resizable: boolean | ResizableStructure) => void;

                                                                  method wireBeans

                                                                  wireBeans: (beans: BeanCollection) => void;

                                                                    class AgGroupComponent

                                                                    class AgGroupComponent extends Component<AgGroupComponentEvent> {}

                                                                      constructor

                                                                      constructor(params?: AgGroupComponentParams);

                                                                        method addCssClassToTitleBar

                                                                        addCssClassToTitleBar: (cssClass: string) => void;

                                                                          method addItem

                                                                          addItem: (item: GroupItem) => void;

                                                                            method addItems

                                                                            addItems: (items: GroupItem[]) => void;

                                                                              method addTitleBarWidget

                                                                              addTitleBarWidget: (el: Element) => this;

                                                                                method getItemIndex

                                                                                getItemIndex: (item: GroupItem) => number | -1;

                                                                                  method hideEnabledCheckbox

                                                                                  hideEnabledCheckbox: (hide: boolean) => this;

                                                                                    method hideItem

                                                                                    hideItem: (hide: boolean, index: number) => void;

                                                                                      method hideOpenCloseIcons

                                                                                      hideOpenCloseIcons: (hide: boolean) => this;

                                                                                        method isEnabled

                                                                                        isEnabled: () => boolean;

                                                                                          method isExpanded

                                                                                          isExpanded: () => boolean;

                                                                                            method onEnableChange

                                                                                            onEnableChange: (callbackFn: (enabled: boolean) => void) => this;

                                                                                              method onExpandedChange

                                                                                              onExpandedChange: (callbackFn: (expanded: boolean) => void) => this;

                                                                                                method postConstruct

                                                                                                postConstruct: () => void;

                                                                                                  method prependItem

                                                                                                  prependItem: (item: GroupItem) => void;

                                                                                                    method setAlignItems

                                                                                                    setAlignItems: (alignment: AgGroupComponentParams['alignItems']) => this;

                                                                                                      method setEnabled

                                                                                                      setEnabled: (
                                                                                                      enabled: boolean,
                                                                                                      skipToggle?: boolean,
                                                                                                      skipExpand?: boolean
                                                                                                      ) => this;

                                                                                                        method setTitle

                                                                                                        setTitle: (title: string) => this;

                                                                                                          method toggleGroupExpand

                                                                                                          toggleGroupExpand: (expanded?: boolean, silent?: boolean) => this;

                                                                                                            class AgMenuItemComponent

                                                                                                            class AgMenuItemComponent extends BeanStub<AgMenuItemComponentEvent> {}

                                                                                                              method activate

                                                                                                              activate: (openSubMenu?: boolean) => void;

                                                                                                                method closeSubMenu

                                                                                                                closeSubMenu: () => void;

                                                                                                                  method deactivate

                                                                                                                  deactivate: () => void;

                                                                                                                    method destroy

                                                                                                                    destroy: () => void;

                                                                                                                      method getGui

                                                                                                                      getGui: () => HTMLElement;

                                                                                                                        method getParentComponent

                                                                                                                        getParentComponent: () => Component | undefined;

                                                                                                                          method getSubMenuGui

                                                                                                                          getSubMenuGui: () => HTMLElement | undefined;

                                                                                                                            method init

                                                                                                                            init: (params: AgMenuItemComponentParams) => AgPromise<void>;

                                                                                                                              method isDisabled

                                                                                                                              isDisabled: () => boolean;

                                                                                                                                method isSubMenuOpen

                                                                                                                                isSubMenuOpen: () => boolean;

                                                                                                                                  method isSubMenuOpening

                                                                                                                                  isSubMenuOpening: () => boolean;

                                                                                                                                    method openSubMenu

                                                                                                                                    openSubMenu: (activateFirstItem?: boolean) => void;

                                                                                                                                      method setParentComponent

                                                                                                                                      setParentComponent: (component: Component<any>) => void;

                                                                                                                                        method wireBeans

                                                                                                                                        wireBeans: (beans: BeanCollection) => void;

                                                                                                                                          class AgMenuItemRenderer

                                                                                                                                          class AgMenuItemRenderer extends Component implements IMenuItemComp {}

                                                                                                                                            constructor

                                                                                                                                            constructor();

                                                                                                                                              method configureDefaults

                                                                                                                                              configureDefaults: () => boolean;

                                                                                                                                                method destroy

                                                                                                                                                destroy: () => void;

                                                                                                                                                  method init

                                                                                                                                                  init: (params: IMenuItemParams & AgMenuItemRendererParams) => void;

                                                                                                                                                    class AgMenuList

                                                                                                                                                    class AgMenuList extends TabGuardComp<AgMenuListEvent> {}

                                                                                                                                                      constructor

                                                                                                                                                      constructor(level?: number, params?: WithoutGridCommon<IMenuActionParams>);

                                                                                                                                                        method activateFirstItem

                                                                                                                                                        activateFirstItem: () => void;

                                                                                                                                                          method addMenuItems

                                                                                                                                                          addMenuItems: (menuItems?: (MenuItemDef | string)[]) => void;

                                                                                                                                                            method clearActiveItem

                                                                                                                                                            clearActiveItem: () => void;

                                                                                                                                                              method destroy

                                                                                                                                                              destroy: () => void;

                                                                                                                                                                method postConstruct

                                                                                                                                                                postConstruct: () => void;

                                                                                                                                                                  class AgMenuPanel

                                                                                                                                                                  class AgMenuPanel extends TabGuardComp {}

                                                                                                                                                                    constructor

                                                                                                                                                                    constructor(wrappedComponent: IComponent<any>);

                                                                                                                                                                      method postConstruct

                                                                                                                                                                      postConstruct: () => void;

                                                                                                                                                                        class AgPanel

                                                                                                                                                                        class AgPanel<TConfig extends PanelOptions = PanelOptions> extends Component {}

                                                                                                                                                                          constructor

                                                                                                                                                                          constructor(config: PanelOptions);

                                                                                                                                                                            property closable

                                                                                                                                                                            protected closable: boolean;

                                                                                                                                                                              property close

                                                                                                                                                                              close: () => void;

                                                                                                                                                                                property CLOSE_BTN_TEMPLATE

                                                                                                                                                                                protected static CLOSE_BTN_TEMPLATE: string;

                                                                                                                                                                                  property closeButtonComp

                                                                                                                                                                                  protected closeButtonComp: any;

                                                                                                                                                                                    property config

                                                                                                                                                                                    protected readonly config: PanelOptions;

                                                                                                                                                                                      property eContentWrapper

                                                                                                                                                                                      protected readonly eContentWrapper: HTMLElement;

                                                                                                                                                                                        property eTitle

                                                                                                                                                                                        protected readonly eTitle: HTMLElement;

                                                                                                                                                                                          property eTitleBar

                                                                                                                                                                                          protected readonly eTitleBar: HTMLElement;

                                                                                                                                                                                            property eTitleBarButtons

                                                                                                                                                                                            protected readonly eTitleBarButtons: HTMLElement;

                                                                                                                                                                                              property positionableFeature

                                                                                                                                                                                              protected positionableFeature: PositionableFeature;

                                                                                                                                                                                                method addTitleBarButton

                                                                                                                                                                                                addTitleBarButton: (button: Component, position?: number) => void;

                                                                                                                                                                                                  method destroy

                                                                                                                                                                                                  destroy: () => void;

                                                                                                                                                                                                    method getBodyHeight

                                                                                                                                                                                                    getBodyHeight: () => number;

                                                                                                                                                                                                      method getBodyWidth

                                                                                                                                                                                                      getBodyWidth: () => number;

                                                                                                                                                                                                        method getHeight

                                                                                                                                                                                                        getHeight: () => number | undefined;

                                                                                                                                                                                                          method getWidth

                                                                                                                                                                                                          getWidth: () => number | undefined;

                                                                                                                                                                                                            method postConstruct

                                                                                                                                                                                                            postConstruct: () => void;

                                                                                                                                                                                                              method renderComponent

                                                                                                                                                                                                              protected renderComponent: () => void;

                                                                                                                                                                                                                method setBodyComponent

                                                                                                                                                                                                                setBodyComponent: (bodyComponent: Component<any>) => void;

                                                                                                                                                                                                                  method setClosable

                                                                                                                                                                                                                  setClosable: (closable: boolean) => void;

                                                                                                                                                                                                                    method setHeight

                                                                                                                                                                                                                    setHeight: (height: number | string) => void;

                                                                                                                                                                                                                      method setTitle

                                                                                                                                                                                                                      setTitle: (title: string) => void;

                                                                                                                                                                                                                        method setWidth

                                                                                                                                                                                                                        setWidth: (width: number | string) => void;

                                                                                                                                                                                                                          class AgPrimaryCols

                                                                                                                                                                                                                          class AgPrimaryCols extends Component {}

                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                            constructor();

                                                                                                                                                                                                                              method collapseGroups

                                                                                                                                                                                                                              collapseGroups: (groupIds?: string[]) => void;

                                                                                                                                                                                                                                method expandGroups

                                                                                                                                                                                                                                expandGroups: (groupIds?: string[]) => void;

                                                                                                                                                                                                                                  method getExpandedGroups

                                                                                                                                                                                                                                  getExpandedGroups: () => string[];

                                                                                                                                                                                                                                    method init

                                                                                                                                                                                                                                    init: (
                                                                                                                                                                                                                                    allowDragging: boolean,
                                                                                                                                                                                                                                    params: ToolPanelColumnCompParams,
                                                                                                                                                                                                                                    eventType: ColumnEventType
                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                      method onCollapseAll

                                                                                                                                                                                                                                      onCollapseAll: () => void;

                                                                                                                                                                                                                                        method onExpandAll

                                                                                                                                                                                                                                        onExpandAll: () => void;

                                                                                                                                                                                                                                          method setColumnLayout

                                                                                                                                                                                                                                          setColumnLayout: (colDefs: (ColDef | ColGroupDef)[]) => void;

                                                                                                                                                                                                                                            method syncLayoutWithGrid

                                                                                                                                                                                                                                            syncLayoutWithGrid: () => void;

                                                                                                                                                                                                                                              method toggleResizable

                                                                                                                                                                                                                                              toggleResizable: (resizable: boolean) => void;

                                                                                                                                                                                                                                                class AgRichSelect

                                                                                                                                                                                                                                                class AgRichSelect<TValue = any> extends AgPickerField<
                                                                                                                                                                                                                                                TValue[] | TValue,
                                                                                                                                                                                                                                                RichSelectParams<TValue>,
                                                                                                                                                                                                                                                AgRichSelectEvent,
                                                                                                                                                                                                                                                AgRichSelectList<TValue, AgRichSelectEvent>
                                                                                                                                                                                                                                                > {}

                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                  constructor(config?: RichSelectParams<TValue>);

                                                                                                                                                                                                                                                    property values

                                                                                                                                                                                                                                                    protected values: TValue[];

                                                                                                                                                                                                                                                      method beforeHidePicker

                                                                                                                                                                                                                                                      protected beforeHidePicker: () => void;

                                                                                                                                                                                                                                                        method createPickerComponent

                                                                                                                                                                                                                                                        protected createPickerComponent: () => AgRichSelectList<
                                                                                                                                                                                                                                                        TValue,
                                                                                                                                                                                                                                                        AgRichSelectListEvent
                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                          method destroy

                                                                                                                                                                                                                                                          destroy: () => void;

                                                                                                                                                                                                                                                            method getFocusableElement

                                                                                                                                                                                                                                                            getFocusableElement: () => HTMLElement;

                                                                                                                                                                                                                                                              method onEnterKeyDown

                                                                                                                                                                                                                                                              protected onEnterKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                method onKeyDown

                                                                                                                                                                                                                                                                protected onKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                  method postConstruct

                                                                                                                                                                                                                                                                  postConstruct: () => void;

                                                                                                                                                                                                                                                                    method searchTextFromString

                                                                                                                                                                                                                                                                    searchTextFromString: (str: string | null | undefined) => void;

                                                                                                                                                                                                                                                                      method setSearchStringCreator

                                                                                                                                                                                                                                                                      setSearchStringCreator: (searchStringFn: (values: TValue[]) => string[]) => void;

                                                                                                                                                                                                                                                                        method setValue

                                                                                                                                                                                                                                                                        setValue: (
                                                                                                                                                                                                                                                                        value: TValue[] | TValue | null,
                                                                                                                                                                                                                                                                        silent?: boolean,
                                                                                                                                                                                                                                                                        fromPicker?: boolean,
                                                                                                                                                                                                                                                                        skipRendering?: boolean
                                                                                                                                                                                                                                                                        ) => this;

                                                                                                                                                                                                                                                                          method setValueList

                                                                                                                                                                                                                                                                          setValueList: (params: { valueList: TValue[]; refresh?: boolean }) => void;

                                                                                                                                                                                                                                                                            method showPicker

                                                                                                                                                                                                                                                                            showPicker: () => void;

                                                                                                                                                                                                                                                                              method wireBeans

                                                                                                                                                                                                                                                                              wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                class GroupCellRenderer

                                                                                                                                                                                                                                                                                class GroupCellRenderer extends Component implements ICellRendererComp {}

                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                  constructor();

                                                                                                                                                                                                                                                                                    method destroy

                                                                                                                                                                                                                                                                                    destroy: () => void;

                                                                                                                                                                                                                                                                                      method init

                                                                                                                                                                                                                                                                                      init: (params: GroupCellRendererParams) => void;

                                                                                                                                                                                                                                                                                        method refresh

                                                                                                                                                                                                                                                                                        refresh: () => boolean;

                                                                                                                                                                                                                                                                                          class GroupCellRendererCtrl

                                                                                                                                                                                                                                                                                          class GroupCellRendererCtrl extends BeanStub implements IGroupCellRendererCtrl {}

                                                                                                                                                                                                                                                                                            method destroy

                                                                                                                                                                                                                                                                                            destroy: () => void;

                                                                                                                                                                                                                                                                                              method getCellAriaRole

                                                                                                                                                                                                                                                                                              getCellAriaRole: () => string;

                                                                                                                                                                                                                                                                                                method init

                                                                                                                                                                                                                                                                                                init: (
                                                                                                                                                                                                                                                                                                comp: IGroupCellRenderer,
                                                                                                                                                                                                                                                                                                eGui: HTMLElement,
                                                                                                                                                                                                                                                                                                eCheckbox: HTMLElement,
                                                                                                                                                                                                                                                                                                eExpanded: HTMLElement,
                                                                                                                                                                                                                                                                                                eContracted: HTMLElement,
                                                                                                                                                                                                                                                                                                compClass: any,
                                                                                                                                                                                                                                                                                                params: GroupCellRendererParams
                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                  method wireBeans

                                                                                                                                                                                                                                                                                                  wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                    class LicenseManager

                                                                                                                                                                                                                                                                                                    class GridLicenseManager extends BeanStub implements NamedBean, IWatermark {}

                                                                                                                                                                                                                                                                                                      property beanName

                                                                                                                                                                                                                                                                                                      beanName: string;

                                                                                                                                                                                                                                                                                                        method getLicenseDetails

                                                                                                                                                                                                                                                                                                        static getLicenseDetails: (
                                                                                                                                                                                                                                                                                                        licenseKey: string
                                                                                                                                                                                                                                                                                                        ) =>
                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                        licenseKey: string;
                                                                                                                                                                                                                                                                                                        valid: boolean;
                                                                                                                                                                                                                                                                                                        missing: boolean;
                                                                                                                                                                                                                                                                                                        currentLicenseType: string;
                                                                                                                                                                                                                                                                                                        incorrectLicenseType?: undefined;
                                                                                                                                                                                                                                                                                                        suppliedLicenseType?: undefined;
                                                                                                                                                                                                                                                                                                        expiry?: undefined;
                                                                                                                                                                                                                                                                                                        expired?: undefined;
                                                                                                                                                                                                                                                                                                        version?: undefined;
                                                                                                                                                                                                                                                                                                        isTrial?: undefined;
                                                                                                                                                                                                                                                                                                        trialExpired?: undefined;
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                        licenseKey: string;
                                                                                                                                                                                                                                                                                                        valid: false;
                                                                                                                                                                                                                                                                                                        incorrectLicenseType: boolean;
                                                                                                                                                                                                                                                                                                        currentLicenseType: string;
                                                                                                                                                                                                                                                                                                        suppliedLicenseType: string | undefined;
                                                                                                                                                                                                                                                                                                        missing?: undefined;
                                                                                                                                                                                                                                                                                                        expiry?: undefined;
                                                                                                                                                                                                                                                                                                        expired?: undefined;
                                                                                                                                                                                                                                                                                                        version?: undefined;
                                                                                                                                                                                                                                                                                                        isTrial?: undefined;
                                                                                                                                                                                                                                                                                                        trialExpired?: undefined;
                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                        | {
                                                                                                                                                                                                                                                                                                        licenseKey: string;
                                                                                                                                                                                                                                                                                                        valid: true;
                                                                                                                                                                                                                                                                                                        expiry: string;
                                                                                                                                                                                                                                                                                                        expired: boolean | undefined;
                                                                                                                                                                                                                                                                                                        version: string | null;
                                                                                                                                                                                                                                                                                                        isTrial: boolean | null;
                                                                                                                                                                                                                                                                                                        trialExpired: undefined;
                                                                                                                                                                                                                                                                                                        incorrectLicenseType: boolean;
                                                                                                                                                                                                                                                                                                        currentLicenseType: string;
                                                                                                                                                                                                                                                                                                        suppliedLicenseType: string | undefined;
                                                                                                                                                                                                                                                                                                        missing?: undefined;
                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                          method getWatermarkMessage

                                                                                                                                                                                                                                                                                                          getWatermarkMessage: () => string;

                                                                                                                                                                                                                                                                                                            method getWatermarkSelector

                                                                                                                                                                                                                                                                                                            getWatermarkSelector: () => ComponentSelector;

                                                                                                                                                                                                                                                                                                              method isDisplayWatermark

                                                                                                                                                                                                                                                                                                              isDisplayWatermark: () => boolean;

                                                                                                                                                                                                                                                                                                                method postConstruct

                                                                                                                                                                                                                                                                                                                postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                  method setChartsLicenseManager

                                                                                                                                                                                                                                                                                                                  static setChartsLicenseManager: (chartsLicenseManager: ILicenseManager) => void;

                                                                                                                                                                                                                                                                                                                    method setLicenseKey

                                                                                                                                                                                                                                                                                                                    static setLicenseKey: (licenseKey: string) => void;

                                                                                                                                                                                                                                                                                                                      method validateLicense

                                                                                                                                                                                                                                                                                                                      validateLicense: () => void;

                                                                                                                                                                                                                                                                                                                        class MultiFilter

                                                                                                                                                                                                                                                                                                                        class MultiFilter extends TabGuardComp implements IFilterComp, IMultiFilter {}

                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                          constructor();

                                                                                                                                                                                                                                                                                                                            method afterGuiAttached

                                                                                                                                                                                                                                                                                                                            afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

                                                                                                                                                                                                                                                                                                                              method afterGuiDetached

                                                                                                                                                                                                                                                                                                                              afterGuiDetached: () => void;

                                                                                                                                                                                                                                                                                                                                method applyModel

                                                                                                                                                                                                                                                                                                                                applyModel: (source?: 'api' | 'ui' | 'rowDataUpdated') => boolean;

                                                                                                                                                                                                                                                                                                                                  method destroy

                                                                                                                                                                                                                                                                                                                                  destroy: () => void;

                                                                                                                                                                                                                                                                                                                                    method doesFilterPass

                                                                                                                                                                                                                                                                                                                                    doesFilterPass: (
                                                                                                                                                                                                                                                                                                                                    params: IDoesFilterPassParams,
                                                                                                                                                                                                                                                                                                                                    filterToSkip?: IFilterComp
                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                      method getChildFilterInstance

                                                                                                                                                                                                                                                                                                                                      getChildFilterInstance: (index: number) => IFilterComp | undefined;

                                                                                                                                                                                                                                                                                                                                        method getFilterDefs

                                                                                                                                                                                                                                                                                                                                        static getFilterDefs: (params: MultiFilterParams) => IMultiFilterDef[];

                                                                                                                                                                                                                                                                                                                                          method getLastActiveFilterIndex

                                                                                                                                                                                                                                                                                                                                          getLastActiveFilterIndex: () => number | null;

                                                                                                                                                                                                                                                                                                                                            method getModel

                                                                                                                                                                                                                                                                                                                                            getModel: () => ProvidedFilterModel | null;

                                                                                                                                                                                                                                                                                                                                              method getModelAsString

                                                                                                                                                                                                                                                                                                                                              getModelAsString: (model: IMultiFilterModel) => string;

                                                                                                                                                                                                                                                                                                                                                method getModelFromUi

                                                                                                                                                                                                                                                                                                                                                getModelFromUi: () => IMultiFilterModel | null;

                                                                                                                                                                                                                                                                                                                                                  method init

                                                                                                                                                                                                                                                                                                                                                  init: (params: MultiFilterParams) => AgPromise<void>;

                                                                                                                                                                                                                                                                                                                                                    method isFilterActive

                                                                                                                                                                                                                                                                                                                                                    isFilterActive: () => boolean;

                                                                                                                                                                                                                                                                                                                                                      method onAnyFilterChanged

                                                                                                                                                                                                                                                                                                                                                      onAnyFilterChanged: () => void;

                                                                                                                                                                                                                                                                                                                                                        method onFocusIn

                                                                                                                                                                                                                                                                                                                                                        protected onFocusIn: (e: FocusEvent) => void;

                                                                                                                                                                                                                                                                                                                                                          method onNewRowsLoaded

                                                                                                                                                                                                                                                                                                                                                          onNewRowsLoaded: () => void;

                                                                                                                                                                                                                                                                                                                                                            method postConstruct

                                                                                                                                                                                                                                                                                                                                                            postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                              method setModel

                                                                                                                                                                                                                                                                                                                                                              setModel: (model: IMultiFilterModel | null) => AgPromise<void>;

                                                                                                                                                                                                                                                                                                                                                                method wireBeans

                                                                                                                                                                                                                                                                                                                                                                wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                  class PillDragComp

                                                                                                                                                                                                                                                                                                                                                                  abstract class PillDragComp<TItem> extends Component<PillDragCompEvent> {}

                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                    dragSourceDropTarget: DropTarget,
                                                                                                                                                                                                                                                                                                                                                                    ghost: boolean,
                                                                                                                                                                                                                                                                                                                                                                    horizontal: boolean,
                                                                                                                                                                                                                                                                                                                                                                    template?: string,
                                                                                                                                                                                                                                                                                                                                                                    agComponents?: ComponentSelector[]
                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                      method addAdditionalAriaInstructions

                                                                                                                                                                                                                                                                                                                                                                      protected addAdditionalAriaInstructions: (
                                                                                                                                                                                                                                                                                                                                                                      ariaInstructions: string[],
                                                                                                                                                                                                                                                                                                                                                                      translate: (key: string, defaultValue: string) => string
                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                        method createGetDragItem

                                                                                                                                                                                                                                                                                                                                                                        protected abstract createGetDragItem: () => () => DragItem<TItem>;

                                                                                                                                                                                                                                                                                                                                                                          method destroy

                                                                                                                                                                                                                                                                                                                                                                          destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                            method getAriaDisplayName

                                                                                                                                                                                                                                                                                                                                                                            protected abstract getAriaDisplayName: () => string;

                                                                                                                                                                                                                                                                                                                                                                              method getDefaultIconName

                                                                                                                                                                                                                                                                                                                                                                              protected getDefaultIconName: () => DragAndDropIcon;

                                                                                                                                                                                                                                                                                                                                                                                method getDisplayName

                                                                                                                                                                                                                                                                                                                                                                                protected abstract getDisplayName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                  method getDisplayValue

                                                                                                                                                                                                                                                                                                                                                                                  protected getDisplayValue: () => string;

                                                                                                                                                                                                                                                                                                                                                                                    method getDragSourceId

                                                                                                                                                                                                                                                                                                                                                                                    protected getDragSourceId: () => string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      method getDragSourceType

                                                                                                                                                                                                                                                                                                                                                                                      protected abstract getDragSourceType: () => DragSourceType;

                                                                                                                                                                                                                                                                                                                                                                                        method getItem

                                                                                                                                                                                                                                                                                                                                                                                        abstract getItem: () => TItem;

                                                                                                                                                                                                                                                                                                                                                                                          method getTooltip

                                                                                                                                                                                                                                                                                                                                                                                          protected abstract getTooltip: () => string | null | undefined;

                                                                                                                                                                                                                                                                                                                                                                                            method isDraggable

                                                                                                                                                                                                                                                                                                                                                                                            protected isDraggable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                              method isRemovable

                                                                                                                                                                                                                                                                                                                                                                                              protected isRemovable: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                method onKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                protected onKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                  postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                    method refreshDraggable

                                                                                                                                                                                                                                                                                                                                                                                                    protected refreshDraggable: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method refreshRemove

                                                                                                                                                                                                                                                                                                                                                                                                      protected refreshRemove: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method setupAria

                                                                                                                                                                                                                                                                                                                                                                                                        protected setupAria: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method setupComponents

                                                                                                                                                                                                                                                                                                                                                                                                          protected setupComponents: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                            method wireBeans

                                                                                                                                                                                                                                                                                                                                                                                                            wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              class PillDropZonePanel

                                                                                                                                                                                                                                                                                                                                                                                                              abstract class PillDropZonePanel<
                                                                                                                                                                                                                                                                                                                                                                                                              TPill extends PillDragComp<TItem>,
                                                                                                                                                                                                                                                                                                                                                                                                              TItem
                                                                                                                                                                                                                                                                                                                                                                                                              > extends Component {}

                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                constructor(horizontal: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                  method addItem

                                                                                                                                                                                                                                                                                                                                                                                                                  addItem: (item: TItem) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    method createPillComponent

                                                                                                                                                                                                                                                                                                                                                                                                                    protected abstract createPillComponent: (
                                                                                                                                                                                                                                                                                                                                                                                                                    item: TItem,
                                                                                                                                                                                                                                                                                                                                                                                                                    dropTarget: DropTarget,
                                                                                                                                                                                                                                                                                                                                                                                                                    ghost: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                    horizontal: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => TPill;

                                                                                                                                                                                                                                                                                                                                                                                                                      method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                      destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        method focusList

                                                                                                                                                                                                                                                                                                                                                                                                                        focusList: (fromBottom?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          method getAriaLabel

                                                                                                                                                                                                                                                                                                                                                                                                                          protected abstract getAriaLabel: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                            method getExistingItems

                                                                                                                                                                                                                                                                                                                                                                                                                            protected abstract getExistingItems: () => TItem[];

                                                                                                                                                                                                                                                                                                                                                                                                                              method getIconName

                                                                                                                                                                                                                                                                                                                                                                                                                              protected abstract getIconName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                method getItems

                                                                                                                                                                                                                                                                                                                                                                                                                                protected abstract getItems: (dragItem: DragItem<TItem>) => TItem[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  method handleDragEnterEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                  protected handleDragEnterEnd: (draggingEvent: DraggingEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method handleDragLeaveEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                    protected handleDragLeaveEnd: (draggingEvent: DraggingEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      method init

                                                                                                                                                                                                                                                                                                                                                                                                                                      init: (params?: PillDropZonePanelParams) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method isHorizontal

                                                                                                                                                                                                                                                                                                                                                                                                                                        isHorizontal: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method isInterestedIn

                                                                                                                                                                                                                                                                                                                                                                                                                                          protected abstract isInterestedIn: (type: DragSourceType) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method isItemDroppable

                                                                                                                                                                                                                                                                                                                                                                                                                                            protected abstract isItemDroppable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            item: TItem,
                                                                                                                                                                                                                                                                                                                                                                                                                                            draggingEvent: DraggingEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              method isPotentialDndItems

                                                                                                                                                                                                                                                                                                                                                                                                                                              protected isPotentialDndItems: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method isSourceEventFromTarget

                                                                                                                                                                                                                                                                                                                                                                                                                                                protected isSourceEventFromTarget: (draggingEvent: DraggingEvent) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method minimumAllowedNewInsertIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected minimumAllowedNewInsertIndex: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method refreshGui

                                                                                                                                                                                                                                                                                                                                                                                                                                                    refreshGui: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toggleResizable

                                                                                                                                                                                                                                                                                                                                                                                                                                                      toggleResizable: (resizable: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method updateItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected abstract updateItems: (items: TItem[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method wireBeans

                                                                                                                                                                                                                                                                                                                                                                                                                                                          wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PivotDropZonePanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PivotDropZonePanel extends BaseDropZonePanel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(horizontal: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getAriaLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected getAriaLabel: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getExistingItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getExistingItems: () => AgColumn[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getIconName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected getIconName: () => DragAndDropIcon;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getTooltipParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getTooltipParams: () => WithoutGridCommon<ITooltipParams>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isItemDroppable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected isItemDroppable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        column: AgColumn,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        draggingEvent: DraggingEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method updateItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected updateItems: (columns: AgColumn[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RowGroupDropZonePanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class RowGroupDropZonePanel extends BaseDropZonePanel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(horizontal: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getAriaLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getAriaLabel: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getExistingItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected getExistingItems: () => AgColumn[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getIconName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected getIconName: () => DragAndDropIcon;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getTooltipParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getTooltipParams: () => WithoutGridCommon<ITooltipParams>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isItemDroppable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected isItemDroppable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          column: AgColumn,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          draggingEvent: DraggingEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method updateItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected updateItems: (columns: AgColumn[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SetFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SetFilter<V = string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extends ProvidedFilter<SetFilterModel, V>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                implements ISetFilter<V> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Parameter V

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type of value in the Set Filter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method afterGuiAttached

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method afterGuiDetached

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    afterGuiDetached: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method applyModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      applyModel: (source?: 'api' | 'ui' | 'rowDataUpdated') => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method areModelsEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected areModelsEqual: (a: SetFilterModel, b: SetFilterModel) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method createBodyTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected createBodyTemplate: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method doesFilterPass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              doesFilterPass: (params: IDoesFilterPassParams) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getAgComponents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected getAgComponents: () => ComponentSelector[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getCssIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getCssIdentifier: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getFilterKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getFilterKeys: () => SetFilterModelValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getFilterType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getFilterType: () => 'set';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getFilterValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getFilterValues: () => (V | null)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getFormattedValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getFormattedValue: (key: string | null) => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getMiniFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getMiniFilter: () => string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getModelAsString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getModelAsString: (model: SetFilterModel) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getModelFromUi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getModelFromUi: () => SetFilterModel | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getPositionableElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected getPositionableElement: () => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getValueModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getValueModel: () => SetValueModel<V> | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getValues: () => SetFilterModelValue;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method handleCancelEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected handleCancelEnd: (e: Event) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method handleKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected handleKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isModelValid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected isModelValid: (model: SetFilterModel) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method onAnyFilterChanged

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              onAnyFilterChanged: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method onNewRowsLoaded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                onNewRowsLoaded: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    refresh: (params: SetFilterParams<any, V>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method refreshFilterValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      refreshFilterValues: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method refreshVirtualList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        refreshVirtualList: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method resetFilterValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resetFilterValues: () => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Public method provided so the user can reset the values of the filter once that it has started.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method resetUiToActiveModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected resetUiToActiveModel: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          currentModel: SetFilterModel | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          afterUiUpdatedFunc?: () => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method resetUiToDefaults

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected resetUiToDefaults: () => AgPromise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setFilterValues

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setFilterValues: (values: (V | null)[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Public method provided so the user can change the value of the filter once the filter has been already started

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Parameter values

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                The values to use.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method setMiniFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              setMiniFilter: (newMiniFilter: string | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setModel: (model: SetFilterModel | null) => AgPromise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setModelIntoUi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected setModelIntoUi: (model: SetFilterModel | null) => AgPromise<void>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setParams: (params: SetFilterParams<any, V>) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method updateUiVisibility

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected updateUiVisibility: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method wireBeans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TabbedLayout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class TabbedLayout extends TabGuardComp {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(params: TabbedLayoutParams);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method focusHeader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              focusHeader: (preventScroll?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method handleKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected handleKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method onTabKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected onTabKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setAfterAttachedParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setAfterAttachedParams: (params: IAfterGuiAttachedParams) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method showFirstItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        showFirstItem: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method showItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          showItem: (tabbedItem: TabbedItem) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method wireBeans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ToolPanelColDefService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ToolPanelColDefService extends BeanStub implements NamedBean {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property beanName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                beanName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method createColumnTree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createColumnTree: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  colDefs: AbstractColDef[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => (AgColumn | AgProvidedColumnGroup)[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method syncLayoutWithGrid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    syncLayoutWithGrid: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    syncLayoutCallback: (colDefs: AbstractColDef[]) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method wireBeans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ValuesDropZonePanel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ValuesDropZonePanel extends BaseDropZonePanel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(horizontal: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getAriaLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected getAriaLabel: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getExistingItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getExistingItems: () => AgColumn[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getIconName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected getIconName: () => DragAndDropIcon;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getTooltipParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getTooltipParams: () => WithoutGridCommon<ITooltipParams>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isItemDroppable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected isItemDroppable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    column: AgColumn,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    draggingEvent: DraggingEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method updateItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected updateItems: (columns: AgColumn[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class VirtualList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class VirtualList<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          C extends Component<any> = Component<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TEventType extends string = ComponentEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > extends TabGuardComp<TEventType> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(params?: VirtualListParams);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property animationFrameService

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected animationFrameService: AnimationFrameService;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method destroy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                destroy: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method drawVirtualRows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected drawVirtualRows: (softRefresh?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method ensureIndexVisible

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ensureIndexVisible: (index: number, scrollPartialIntoView?: boolean) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Returns true if the view had to be scrolled, otherwise, false.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method focusInnerElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected focusInnerElement: (fromBottom: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method focusRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      focusRow: (rowNumber: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method forEachRenderedRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        forEachRenderedRow: (func: (comp: C, idx: number) => void) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getAriaElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          getAriaElement: () => Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getComponentAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getComponentAt: (rowIndex: number) => C | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getLastFocusedRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getLastFocusedRow: () => number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getRowHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getRowHeight: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getScrollTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getScrollTop: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method handleKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected handleKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method navigateToPage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      navigateToPage: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: 'Home' | 'PageUp' | 'PageDown' | 'End',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fromItem?: number | 'focused'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method onFocusIn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected onFocusIn: (e: FocusEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method onFocusOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected onFocusOut: (e: FocusEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method onTabKeyDown

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected onTabKeyDown: (e: KeyboardEvent) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method refresh

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                refresh: (softRefresh?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method setComponentCreator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setComponentCreator: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  componentCreator: (value: any, listItemElement: HTMLElement) => C
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method setComponentUpdater

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    setComponentUpdater: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    componentUpdater: (value: any, component: C) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method setModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      setModel: (model: VirtualListModel) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method setRowHeight

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        setRowHeight: (rowHeight: number) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method wireBeans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class VirtualListDragFeature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class VirtualListDragFeature<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            C extends Component<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            R extends Component<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            V,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            E extends AgEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > extends BeanStub {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              comp: Component<any>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              virtualList: VirtualList<any, ComponentEvent>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              params: VirtualListDragParams<C, R, V, E>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method postConstruct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                postConstruct: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method wireBeans

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  wireBeans: (beans: BeanCollection) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AgGroupComponentParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface AgGroupComponentParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property alignItems

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alignItems?: Align;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property cssIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cssIdentifier?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property direction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          direction?: Direction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property enabled

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            enabled?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property expanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              expanded?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                items?: GroupItem[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property onEnableChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  onEnableChange?: (enabled: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property onExpandedChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    onExpandedChange?: (expanded: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property suppressEnabledCheckbox

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      suppressEnabledCheckbox?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property suppressKeyboardNavigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        suppressKeyboardNavigation?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property suppressOpenCloseIcons

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          suppressOpenCloseIcons?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property suppressToggleExpandOnEnableChange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            suppressToggleExpandOnEnableChange?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              title?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property useToggle

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                useToggle?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloseMenuEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface CloseMenuEvent extends AgEvent<'closeMenu'> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property keyboardEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    keyboardEvent?: KeyboardEvent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property mouseEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      mouseEvent?: MouseEvent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ILicenseManager

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ILicenseManager {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property setLicenseKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          setLicenseKey: (key?: string, gridContext?: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MenuItemActivatedEvent extends AgEvent<'menuItemActivated'> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              menuItem: AgMenuItemComponent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PillDropZonePanelParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PillDropZonePanelParams {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property emptyMessage

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  emptyMessage?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property icon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    icon?: Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      title?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabbedItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TabbedItem {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property afterAttachedCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          afterAttachedCallback?: (params: IAfterGuiAttachedParams) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property afterDetachedCallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            afterDetachedCallback?: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bodyPromise

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bodyPromise: AgPromise<HTMLElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property getScrollableContainer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getScrollableContainer?: () => HTMLElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property title

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    title: Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property titleLabel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      titleLabel: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VirtualListDragItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface VirtualListDragItem<R extends Component<any>> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          component: R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            position: 'top' | 'bottom';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property rowIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rowIndex: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface VirtualListDragParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface VirtualListDragParams<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                C extends Component,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                R extends Component,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                V,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                E extends AgEvent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property dragSourceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  dragSourceType: DragSourceType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property eventSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    eventSource: Window | HTMLElement | IEventEmitter<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property getCurrentDragValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getCurrentDragValue: (listItemDragStartEvent: E) => V;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property getNumRows

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getNumRows: (comp: C) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property isMoveBlocked

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isMoveBlocked: (currentDragValue: V | null) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property listItemDragEndEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            listItemDragEndEvent:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'columnPanelItemDragEnd'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 'advancedFilterBuilderDragEnded';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property listItemDragStartEvent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              listItemDragStartEvent:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'columnPanelItemDragStart'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 'advancedFilterBuilderDragStarted';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property moveItem

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                moveItem: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                currentDragValue: V | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lastHoveredListItem: VirtualListDragItem<R> | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VirtualListModel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface VirtualListModel {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method areRowsEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    areRowsEqual: (oldRow: any, newRow: any) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Required if using soft refresh. If rows are equal, componentUpdater will be called instead of remove/create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getRow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getRow: (index: number) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getRowCount

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getRowCount: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (49)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (28)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ag-grid-enterprise.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ag-grid-enterprise)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/ag-grid-enterprise"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>