ag-grid-enterprise

  • Version 33.0.4
  • Published
  • 21.3 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

Variables

variable AdvancedFilterModule

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

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 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 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 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 RowGroupingModule

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

variable RowGroupingPanelModule

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

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 exportMultipleSheetsAsExcel

exportMultipleSheetsAsExcel: (params: ExcelExportMultipleSheetParams) => void;

    function getMultipleSheetsAsExcel

    getMultipleSheetsAsExcel: (
    params: ExcelExportMultipleSheetParams
    ) => 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;

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

                                                                class SetFilter

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

                                                                  type of value in the Set Filter

                                                                constructor

                                                                constructor();

                                                                  property filterType

                                                                  protected filterType: string;

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

                                                                                                      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;

                                                                                                                                          Package Files (26)

                                                                                                                                          Dependencies (1)

                                                                                                                                          Dev Dependencies (15)

                                                                                                                                          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>