ag-grid-enterprise

  • Version 34.3.0
  • Published
  • 24.4 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 AiToolkitModule

const AiToolkitModule: _ModuleWithApi<_AiToolkitGridApi>;

    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 FindModule

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

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

                                                                                                                  Package Files (29)

                                                                                                                  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>