ag-grid-enterprise

  • Version 35.2.0
  • Published
  • 25.5 MB
  • 1 dependency
  • 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

Namespaces

Variables

variable AdvancedFilterModule

const AdvancedFilterModule: _ModuleWithApi<_AdvancedFilterGridApi>;
  • Filtering -> Advanced Filter enableAdvanced Filter

variable AiToolkitModule

const AiToolkitModule: _ModuleWithApi<_AiToolkitGridApi>;
  • AI Toolkit

variable AllEnterpriseModule

const AllEnterpriseModule: any;
  • All Enterprise and Community features Registers all the Grid features: Community and Enterprise. If using Integrated Charts or Sparklines then the relevant AG Charts module must be provided.

    Example 1

    // All Enterprise features import { ModuleRegistry } from 'ag-grid-community'; import { AllEnterpriseModule } from 'ag-grid-enterprise';

    ModuleRegistry.registerModules([ AllEnterpriseModule ]);

    Example 2

    // All Enterprise features including Integrated Charts and Sparklines import { ModuleRegistry } from 'ag-grid-community'; import { AgChartsEnterpriseModule } from 'ag-charts-enterprise'; import { AllEnterpriseModule } from 'ag-grid-enterprise';

    ModuleRegistry.registerModules([ AllEnterpriseModule.with(AgChartsEnterpriseModule) ]);

variable BatchEditModule

const BatchEditModule: _ModuleWithApi<_BatchEditApi>;
  • Batch Editing

variable CellSelectionModule

const CellSelectionModule: _ModuleWithApi<_CellSelectionGridApi>;
  • Selection -> Cell Selection cellSelection

variable ClipboardModule

const ClipboardModule: _ModuleWithApi<_ClipboardGridApi>;
  • Import & Export -> Clipboard

variable ColumnMenuModule

const ColumnMenuModule: _ModuleWithApi<_ColumnChooserGridApi>;
  • Accessories -> Column Menu

variable ColumnsToolPanelModule

const ColumnsToolPanelModule: _ModuleWithoutApi;
  • Accessories -> Columns Tool Panel

variable ContextMenuModule

const ContextMenuModule: _ModuleWithApi<_ContextMenuGridApi>;
  • Accessories -> Context Menu

variable ExcelExportModule

const ExcelExportModule: _ModuleWithApi<_ExcelExportGridApi>;
  • Import & Export -> Excel

variable FiltersToolPanelModule

const FiltersToolPanelModule: _ModuleWithoutApi;
  • Accessories -> Filters Tool Panel

variable FindModule

const FindModule: _ModuleWithApi<_FindApi<any>>;
  • Find findSearchValue

variable FormulaModule

const FormulaModule: _ModuleWithoutApi;
  • Formulas

variable GridChartsModule

const GridChartsModule: _ModuleWithApi<_GridChartsGridApi>;
  • Deprecated

    v33 Deprecated as of v33, please use IntegratedChartsModule instead.

variable GroupFilterModule

const GroupFilterModule: _ModuleWithoutApi;
  • Row Grouping -> Filtering

variable IntegratedChartsModule

const IntegratedChartsModule: any;
  • Integrated Charts Requires the AG Charts library to be provided to this module via the with method. The AG Charts module can be imported from either ag-charts-community or ag-charts-enterprise.

    Example 1

    import { AgChartsEnterpriseModule } from 'ag-charts-enterprise'; import { ModuleRegistry } from 'ag-grid-community'; import { IntegratedChartsModule } from 'ag-grid-enterprise';

    ModuleRegistry.registerModules([ IntegratedChartsModule.with(AgChartsEnterpriseModule) ]);

variable MasterDetailModule

const MasterDetailModule: _ModuleWithoutApi;
  • Master Detail masterDetail

const MenuModule: _ModuleWithoutApi;
  • Accessories -> Column Menu / Context Menu

variable MultiFilterModule

const MultiFilterModule: _ModuleWithoutApi;
  • Filtering -> Multi Filter

variable NewFiltersToolPanelModule

const NewFiltersToolPanelModule: _ModuleWithoutApi;
  • Accessories -> New Filters Tool Panel

variable PivotModule

const PivotModule: _ModuleWithoutApi;
  • Pivoting pivot, enablePivot pivotMode

variable RangeSelectionModule

const RangeSelectionModule: _ModuleWithoutApi;
  • Deprecated

    v33 Use CellSelectionModule instead

variable RichSelectModule

const RichSelectModule: _ModuleWithoutApi;
  • Editing -> Rich Select Editor

variable RowGroupingEditModule

const RowGroupingEditModule: _ModuleWithoutApi;
  • Editing -> Group Row Edit Enables groupRowEditable and groupRowValueSetter on group rows. When groupRowEditable is set but no groupRowValueSetter is provided, the module supplies the builtin that distributes the edited value to descendant rows.

variable RowGroupingModule

const RowGroupingModule: _ModuleWithoutApi;
  • Row Grouping enableRowGroup, rowGroup, rowGroupIndex

variable RowGroupingPanelModule

const RowGroupingPanelModule: _ModuleWithoutApi;
  • Row Grouping -> Row Group Panel

variable RowNumbersModule

const RowNumbersModule: _ModuleWithoutApi;
  • Rows -> Row Numbers rowNumbers

variable ServerSideRowModelApiModule

const ServerSideRowModelApiModule: _ModuleWithApi<_ServerSideRowModelGridApi<any>>;
  • Server-Side Row Model

variable ServerSideRowModelModule

const ServerSideRowModelModule: _ModuleWithoutApi;
  • Server-Side Row Model

variable SetFilterModule

const SetFilterModule: _ModuleWithoutApi;
  • Filtering -> Set Filter

variable SideBarModule

const SideBarModule: _ModuleWithApi<_SideBarGridApi<any>>;
  • Accessories -> Side Bar sideBar

variable SparklinesModule

const SparklinesModule: any;
  • Sparklines Requires the AG Charts library to be provided to this module via the with method. The AG Charts module can be imported from either ag-charts-community or ag-charts-enterprise.

    Example 1

    import { AgChartsCommunityModule } from 'ag-charts-community'; import { ModuleRegistry } from 'ag-grid-community'; import { SparklinesModule } from 'ag-grid-enterprise';

    ModuleRegistry.registerModules([ SparklinesModule.with(AgChartsCommunityModule) ]);

variable StatusBarModule

const StatusBarModule: _ModuleWithApi<_StatusBarGridApi>;
  • Accessories -> Status Bar statusBar

variable TreeDataModule

const TreeDataModule: _ModuleWithoutApi;
  • Tree Data treeData

variable ViewportRowModelModule

const ViewportRowModelModule: _ModuleWithoutApi;
  • Viewport Row Model

Functions

function distributeGroupValue

distributeGroupValue: (
params: GroupRowValueSetterParams,
options?: GroupRowValueSetterOptions
) => boolean;
  • Built-in groupRowValueSetter that distributes a group-level value edit down to descendant rows, respecting the column's aggregation function.

    Assign directly for default behaviour (uniform for sum, overwrite for avg/no-aggFunc):

    colDef.groupRowValueSetter = distributeGroupValue;

    With options (precision rounding, per-aggFunc record):

    colDef.groupRowValueSetter = (params) =>
    distributeGroupValue(params, { distribution: 'percentage', precision: 2 });

    Returns

    true if at least one child value was changed, false otherwise.

function exportMultipleSheetsAsExcel

exportMultipleSheetsAsExcel: (params: ExcelExportMultipleSheetParams) => void;

    function getMultipleSheetsAsExcel

    getMultipleSheetsAsExcel: (
    params: ExcelExportMultipleSheetParams,
    workbook?: Workbook
    ) => Blob | undefined;

      Classes

      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<Component>;

                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 BaseMultiFilter<MultiFilterWrapper>
                          implements IFilterComp, IMultiFilter {}

                            property filterType

                            readonly filterType: string;

                              method applyModel

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

                                method destroy

                                destroy: () => void;

                                  method doesFilterPass

                                  doesFilterPass: (params: IDoesFilterPassParams, indexToSkip?: number) => boolean;

                                    method executeOnWrapper

                                    protected executeOnWrapper: (
                                    wrapper: MultiFilterWrapper,
                                    name: 'onAnyFilterChanged' | 'onNewRowsLoaded'
                                    ) => void;

                                      method getChildFilterInstance

                                      getChildFilterInstance: <TFilter = IFilter>(
                                      index: number
                                      ) => TFilter | undefined;

                                        method getCompFromWrapper

                                        protected getCompFromWrapper: (
                                        wrapper: MultiFilterWrapper
                                        ) => BaseFilterComponent;

                                          method getFilterFromWrapper

                                          protected getFilterFromWrapper: (
                                          wrapper: MultiFilterWrapper
                                          ) => IFilterComp<any>;

                                            method getFilterWrappers

                                            protected getFilterWrappers: () => (MultiFilterWrapper | null)[];

                                              method getLastActiveFilterIndex

                                              getLastActiveFilterIndex: () => number | null;

                                                method getModel

                                                getModel: () => ProvidedFilterModel | null;

                                                  method getModelAsString

                                                  getModelAsString: (model: IMultiFilterModel) => string;

                                                    method getModelFromUi

                                                    getModelFromUi: () => IMultiFilterModel | null;

                                                      method getNumChildFilters

                                                      getNumChildFilters: () => number;

                                                        method init

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

                                                          method isFilterActive

                                                          isFilterActive: () => boolean;

                                                            method refresh

                                                            refresh: (params: IFilterParams) => boolean;

                                                              method setModel

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

                                                                class SetFilter

                                                                class SetFilter<V = string>
                                                                extends ProvidedFilter<
                                                                SetFilterModel,
                                                                V,
                                                                ISetFilterParams<any, V> & FilterDisplayParams<any, any, SetFilterModel>
                                                                >
                                                                implements ISetFilter<V>, SetFilterUi<V> {}
                                                                • Parameter V

                                                                  type of value in the Set Filter

                                                                constructor

                                                                constructor();

                                                                  property filterType

                                                                  readonly filterType: string;

                                                                    property handler

                                                                    handler: SetFilterHandler<V>;

                                                                      method afterGuiAttached

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

                                                                        method afterGuiDetached

                                                                        afterGuiDetached: () => void;

                                                                          method areNonNullModelsEqual

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

                                                                            method canApply

                                                                            protected canApply: (model: SetFilterModel | null) => boolean;

                                                                              method createBodyTemplate

                                                                              protected createBodyTemplate: () => ElementParams | null;

                                                                                method destroy

                                                                                destroy: () => void;

                                                                                  method getAgComponents

                                                                                  protected getAgComponents: () => ComponentSelector[];

                                                                                    method getFilterHandler

                                                                                    getFilterHandler: () => ISetFilterHandler<V>;

                                                                                      method getFilterKeys

                                                                                      getFilterKeys: () => SetFilterModelValue;
                                                                                      • Deprecated

                                                                                        v34 Use the same method on the filter handler (api.getColumnFilterHandler()) instead.

                                                                                      method getFilterValues

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

                                                                                        v34 Use the same method on the filter handler (api.getColumnFilterHandler()) instead.

                                                                                      method getMiniFilter

                                                                                      getMiniFilter: () => string | null;

                                                                                        method getModelAsString

                                                                                        getModelAsString: (model: SetFilterModel | null) => string;

                                                                                          method getModelFromUi

                                                                                          getModelFromUi: () => SetFilterModel | null;

                                                                                            method getPositionableElement

                                                                                            protected getPositionableElement: () => HTMLElement;

                                                                                              method getState

                                                                                              protected getState: () => any;

                                                                                                method getUiChangeEventParams

                                                                                                protected getUiChangeEventParams: () => any;

                                                                                                  method handleKeyDown

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

                                                                                                    method onAnyFilterChanged

                                                                                                    onAnyFilterChanged: () => void;
                                                                                                    • Deprecated

                                                                                                      v34 Internal method - should only be called by the grid.

                                                                                                    method onNewRowsLoaded

                                                                                                    onNewRowsLoaded: () => void;
                                                                                                    • Deprecated

                                                                                                      v34 Internal method - should only be called by the grid.

                                                                                                    method refresh

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

                                                                                                      method refreshFilterValues

                                                                                                      refreshFilterValues: () => void;
                                                                                                      • Deprecated

                                                                                                        v34 Use the same method on the filter handler (api.getColumnFilterHandler()) instead.

                                                                                                      method resetFilterValues

                                                                                                      resetFilterValues: () => void;
                                                                                                      • Deprecated

                                                                                                        v34 Use the same method on the filter handler (api.getColumnFilterHandler()) instead.

                                                                                                      method setFilterValues

                                                                                                      setFilterValues: (values: (V | null)[]) => void;
                                                                                                      • Deprecated

                                                                                                        v34 Use the same method on the filter handler (api.getColumnFilterHandler()) instead.

                                                                                                      method setMiniFilter

                                                                                                      setMiniFilter: (newMiniFilter: string | null, silent?: boolean) => void;

                                                                                                        method setModelIntoUi

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

                                                                                                          method setParams

                                                                                                          protected setParams: (
                                                                                                          params: ISetFilterParams<any, V> &
                                                                                                          FilterDisplayParams<any, any, SetFilterModel>
                                                                                                          ) => void;

                                                                                                            method updateParams

                                                                                                            protected updateParams: (
                                                                                                            newParams: ISetFilterParams<any, V> &
                                                                                                            FilterDisplayParams<any, any, SetFilterModel>,
                                                                                                            oldParams: ISetFilterParams<any, V> &
                                                                                                            FilterDisplayParams<any, any, SetFilterModel>
                                                                                                            ) => void;

                                                                                                              method updateUiVisibility

                                                                                                              protected updateUiVisibility: () => void;

                                                                                                                Namespaces

                                                                                                                namespace *.css

                                                                                                                module '*.css' {}

                                                                                                                  variable css

                                                                                                                  const css: string;

                                                                                                                    Package Files (34)

                                                                                                                    Dependencies (1)

                                                                                                                    Dev Dependencies (7)

                                                                                                                    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>