@genesislcap/grid-pro 15.35.1 → 16.0.0

package/dist/esm/{grid-pro-beta.js → grid-pro-legacy.js}

@@ -1,108 +1,64 @@
 import { __awaiter, __decorate, __rest } from "tslib";
+import { ClientSideRowModelModule } from '@ag-grid-community/client-side-row-model';
+import { ComponentUtil, Events, Grid, ModuleRegistry } from '@ag-grid-community/core';
+import { CsvExportModule } from '@ag-grid-community/csv-export';
 import { DatasourceDefaults } from '@genesislcap/foundation-comms';
-import { avoidTreeShaking, LifecycleMixin, respondToVisibility, } from '@genesislcap/foundation-utils';
-import { baseLayerLuminance, StandardLuminance } from '@microsoft/fast-components';
+import { avoidTreeShaking, insertDocumentCSSRule, LifecycleMixin, respondToVisibility, } from '@genesislcap/foundation-utils';
 import { attr, DOM, observable } from '@microsoft/fast-element';
 import { FoundationElement } from '@microsoft/fast-foundation';
-import { CellStyleModule, CheckboxEditorModule, ClientSideRowModelApiModule, ClientSideRowModelModule, ColumnApiModule, ColumnAutoSizeModule, createGrid, CsvExportModule, CustomEditorModule, CustomFilterModule, DateEditorModule, DateFilterModule, DragAndDropModule, EventApiModule, HighlightChangesModule, InfiniteRowModelModule, ModuleRegistry, NumberEditorModule, NumberFilterModule, PaginationModule, RenderApiModule, RowApiModule, RowDragModule, RowSelectionModule, RowStyleModule, SelectEditorModule, TextEditorModule, TextFilterModule, TooltipModule, _ColumnMoveModule as ColumnMoveModule, } from 'ag-grid-community';
+import { classNames } from '@microsoft/fast-web-utilities';
 import * as changeCase from 'change-case';
 import debounce from 'lodash.debounce';
 import { GridProCell } from './cell';
 import { DateEditor, MultiselectEditor, NumberEditor, SelectEditor, StringEditor, } from './cell-editors';
 import { ActionRenderer, ActionsMenuRenderer, BooleanRenderer, EditableRenderer, IconRenderer, SelectRenderer, StatusPillRenderer, } from './cell-renderers';
 import { GridProColumn, resolveVisibleColumnFields } from './column';
-import { EnumColumnFilter, EnumColumnFloatingFilter, GridProFilterTypes } from './column-filters';
-import { ColumnSelection } from './column-selection';
-import { GRID_PRO_COLUMN_DRAG_BRIDGE_CONTEXT_KEY, gridProColumnDragBridgeModule, } from './column-selection/grid-pro-column-drag-bridge';
-import { GridProClientSideDatasource, GridProInfiniteDatasource, GridProServerSideDatasource, } from './datasource';
+import { GridProClientSideDatasource, GridProServerSideDatasource } from './datasource';
 import { baseDatasourceEventNames } from './datasource/base.types';
+import { agThemeFontFaceMap, defaultAgGridFontFace } from './external';
 import { GridProGenesisDatasource, gridProGenesisDatasourceEventNames, } from './grid-pro-genesis-datasource';
 import { datasourceEventNames, } from './grid-pro-genesis-datasource/datasource-events.types';
-import { AG_PROPERTIES, copyAttributesToGridOptions, DEBOUNCED_RESIZE_TIME, gridProErrorNames, gridProEventNames, } from './grid-pro.definitions';
-import { DEFAULT_STATUS_BAR_CONFIG, EDITED_COLUMN_FIELD, ERROR_COLUMN_FIELD, GRID_READY_EVENT, GridOptionsConfig, GridProRendererTypes, GridProStatusBarTypes, } from './grid-pro.types';
+import { AG_PROPERTIES, copyAttributesToGridOptions, DEBOUNCED_RESIZE_TIME, defaultGridProConfig, foundationGridProShadowOptions, gridProErrorNames, gridProEventNames, } from './grid-pro.definitions';
+import { foundationGridProStyles as styles } from './grid-pro.styles';
+import { gridProTemplate as template } from './grid-pro.template';
+import { AgGridTheme, agThemeFontsId, agThemeTokenMapClassname, DEFAULT_STATUS_BAR_CONFIG, EDITED_COLUMN_FIELD, ERROR_COLUMN_FIELD, GRID_READY_EVENT, GridOptionsConfig, GridProRendererTypes, GridProStatusBarTypes, } from './grid-pro.types';
 import { StatePersistence } from './state-persistence';
 import { LabelValueStatusBarComponent, LoadMoreStatusBarComponent, ReloadStatusBarComponent, RowCountStatusBarComponent, } from './status-bar-components';
 import { ErrorTooltip } from './tooltips';
-import { convertToKebabCase, logger, mergeAndDedupColDefWithColumnState, sanitizeColumnState, } from './utils';
-avoidTreeShaking(GridProGenesisDatasource, GridProClientSideDatasource, GridProServerSideDatasource, GridProInfiniteDatasource, GridProCell, GridProColumn, ColumnSelection);
-ModuleRegistry.registerModules([
-    CsvExportModule,
-    ClientSideRowModelModule,
-    PaginationModule,
-    RowStyleModule,
-    ClientSideRowModelApiModule,
-    EventApiModule,
-    TextFilterModule,
-    HighlightChangesModule,
-    ColumnApiModule,
-    NumberFilterModule,
-    CellStyleModule,
-    DateFilterModule,
-    RowApiModule,
-    TooltipModule,
-    ColumnAutoSizeModule,
-    RenderApiModule,
-    RowDragModule,
-    RowSelectionModule,
-    CustomEditorModule,
-    TextEditorModule,
-    NumberEditorModule,
-    DateEditorModule,
-    SelectEditorModule,
-    CheckboxEditorModule,
-    CustomFilterModule,
-    InfiniteRowModelModule,
-    DragAndDropModule,
-    ColumnMoveModule,
-    gridProColumnDragBridgeModule,
-    // ValidationModule,
-]);
+import { convertColDefsToColumnStates, convertToKebabCase, logger, mergeAndDedupColDefWithColumnState, sanitizeColumnState, } from './utils';
+avoidTreeShaking(GridProGenesisDatasource, GridProClientSideDatasource, GridProServerSideDatasource, GridProCell, GridProColumn);
+ModuleRegistry.registerModules([CsvExportModule, ClientSideRowModelModule]);
 const DEBOUNCE_TIME = 400;
-const Events = {
-    EVENT_GRID_READY: 'gridReady',
-};
+// Re-export AG_PROPERTIES from definitions for backwards compatibility
+export { AG_PROPERTIES };
 /**
- * Finds `key`'s accessor among the component's own prototypes.
- * @remarks Own properties are skipped because the caller installs one: `connectedCallback` can run
- * more than once, and starting from the instance would wrap the accessor it defined last time. The
- * walk stops at `HTMLElement` so that a property merely sharing a name with a native one (such as
- * `tabIndex`) is left alone instead of picking up DOM semantics through the caller.
- * @internal
- */
-function findDeclaredAccessor(target, key) {
-    let proto = Object.getPrototypeOf(target);
-    while (proto && proto !== HTMLElement.prototype) {
-        const descriptor = Object.getOwnPropertyDescriptor(proto, key);
-        if (descriptor)
-            return descriptor;
-        proto = Object.getPrototypeOf(proto);
-    }
-    return undefined;
-}
-/**
- * The Grid Pro element (AG Grid v35 compatible).
- * @remarks Grid Pro is a Web Component wrapper around the AG Grid Community library.
- * @beta
+ * The Grid Pro Legacy element (AG Grid v29 compatible).
+ * @remarks Grid Pro Legacy is a Web Component wrapper around the AG Grid Community library.
+ * @public
+ * @deprecated Legacy AG Grid v29 wrapper. Use `GridPro` (AG Grid v36) instead.
  * @tagname %%prefix%%-grid-pro
  *
- * @fires gridReady - Fired when AG Grid is ready (detail includes the grid-ready event and grid id). detail: `GridReadyEventDetail`
- * @fires onGridReady - Deprecated alias for the grid-ready signal; prefer `gridReady`. detail: `GridReadyEventDetail`
+ * @fires gridReady - Fired when AG Grid is ready (detail includes the grid-ready event and grid id)
+ * @fires onGridReady - Deprecated alias for the grid-ready signal; prefer `gridReady`
  * @fires gridready - Native `Event` from `globalEventListener` when AG Grid fires `gridReady` (`agGridDetails` holds the AG Grid event)
- * @remarks Re-emits AG Grid public API events when listeners are registered via `addEventListener` (event names match AG Grid public event strings). The same AG Grid events are also dispatched as native `Event`s with lowercased `type` and payload on `agGridDetails` (for example `addEventListener('columnresized', ...)`).
+ * @remarks Re-emits AG Grid public API events when listeners are registered via `addEventListener` (event names match `ComponentUtil.PUBLIC_EVENTS` from `@ag-grid-community/core`). The same AG Grid events are also dispatched as native `Event`s with lowercased `type` and payload on `agGridDetails` (for example `addEventListener('columnresized', ...)`).
  */
-export class GridProBeta extends LifecycleMixin(FoundationElement) {
-    /** @internal Shared AG column-drag bridge for custom tool panels. */
-    getColumnDragBridge() {
-        return this.columnDragBridge;
-    }
+export class GridProLegacy extends LifecycleMixin(FoundationElement) {
     rowDataChanged(_, rowData) {
-        // `initialised` flips true right after createGrid(), but `gridApi` is only assigned in the
-        // async onGridReady callback — so a binding push in that window would crash on an undefined
-        // api. Skipping is lossless: onGridReady applies `this.rowData` itself once the api exists,
-        // and FAST has already stored the new value on the instance before calling this handler.
+        // `initialised` flips true before `gridApi` is assigned (mid-reinit), so relying on it
+        // alone here can crash setRowData with an undefined api.
         if (this.initialised && this.gridApi) {
-            this.gridApi.setGridOption('rowData', rowData);
+            this.gridApi.setRowData(rowData);
+        }
+    }
+    themeChanged(oldValue, newValue) {
+        if (!newValue) {
+            this.classNames = '';
+            this.destroyFontFace();
+            return;
         }
+        this.classNames = classNames(agThemeTokenMapClassname(newValue), newValue);
+        this.insertFontFace(newValue);
     }
     /**
      * The slot ref binds asynchronously, and the queued `initGrid` skips any run that beats it. FAST
@@ -118,9 +74,6 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             this.initGrid();
         }
     }
-    enableColumnSelectionChanged() {
-        this.syncColumnSelectionHostLayout();
-    }
     getfilterModel() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.persistFilterModelKey) {
@@ -141,6 +94,9 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
     }
     constructor() {
         super();
+        // Cache for total column width to avoid repeated calculations
+        this.cachedTotalColumnWidth = null;
+        this.columnCount = 0;
         this.gridErrorItems = [];
         this.disposed = false;
         this.debouncedSaveColumnState = debounce(this.saveColumnState.bind(this), DEBOUNCE_TIME);
@@ -151,24 +107,64 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         // Genesis-specific attrs
         this.autoCellRendererByType = false;
         this.onlyTemplateColDefs = false;
+        // AG-specific attrs
         /**
          * Boolean attribute to control whether the grid autosizes the columns upon interaction.
          * This will disable the column widths from being manually set, and doesn't save the widths
          * in local storage if you are using `persist-column-state-key`.
          */
         this.gridAutosizingEnabled = false;
+        /**
+         * Boolean attribute to control whether the grid automatically sizes columns to fit their content.
+         * This will call AG Grid's autoSizeColumns() method to automatically adjust column widths based on content.
+         * @public
+         */
+        this.sizeColumnsToContent = false;
+        /**
+         * Boolean attribute to adjust the size of columns to fit the available horizontal space.
+         * This will call AG Grid's sizeColumnsToFit() method.
+         * @public
+         */
+        this.sizeColumnsToFit = false;
+        /**
+         * The index to add new rows to when using `applyTransaction` or `applyTransactionAsync`
+         */
+        this.addIndex = 0;
+        /**
+         * Whether to use the `applyTransactionAsync` function for *add* transactions
+         * @remarks Defaults to false
+         */
+        this.asyncAdd = false;
+        /**
+         * Whether to use the `applyTransactionAsync` function for *remove* transactions
+         * @remarks Defaults to false
+         */
+        this.asyncRemove = false;
+        /**
+         * Whether to use the `applyTransactionAsync` function for *update* transactions
+         * @remarks Defaults to true
+         */
+        this.asyncUpdate = true;
         /**
          * If false, will disable cell flashing for all cells by default, unless otherwise defined in custom colDef
          * @remarks Defaults to true
          */
         this.enableCellFlashing = false;
+        /**
+         * @deprecated - use `enableRowFlashing` instead.
+         */
+        this.enabledRowFlashing = false;
         /**
          * If true, will enable row flashing for all rows for `add` async transactions
          */
         this.enableRowFlashing = false;
-        /** Wired to `gridOptions.context` for columns picker → grid drag (see bridge module). */
-        this.columnDragBridge = {};
+        /**
+         * The default column config to reset to when deleteColumnState is called.
+         */
+        this.defaultColumnConfig = [];
+        this.gridFontFace = defaultAgGridFontFace;
         this.columnComponentName = 'grid-pro-column';
+        this.theme = AgGridTheme.alpine;
         this.themeMode = 'dark';
         /**
          * Configuration for the grid status bar components.
@@ -186,27 +182,14 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
          * This requires AG Grid Enterprise module to be available for the status bar to be displayed when enabled.
          */
         this.withStatusBar = false;
-        /**
-         * Shows a Column Selection button above the grid.
-         * @public
-         */
-        this.enableColumnSelection = false;
         this.applyingDatasourceGridOptions = false;
         this.rehydrationAttempted = false;
-        this.rootEventsListeners = [];
-        this.datasourceEventHandlers = [];
+        this.eventHandlers = [];
         this.gridEventsQueue = [];
         this.registeredGridEvents = new Set();
         this.gridEventListeners = new Map();
         this.boundGlobalEventListener = this.globalEventListener.bind(this);
         this._filterConfig = undefined;
-        this.handleLuminanceChange = (record) => {
-            const luminance = baseLayerLuminance.getValueFor(record.target);
-            this.themeMode = luminance === StandardLuminance.DarkMode ? 'dark' : 'light';
-        };
-        this.luminanceObserver = {
-            handleChange: (record) => this.handleLuminanceChange(record),
-        };
         this.agAttributes = {};
         this.agPropertiesMap = AG_PROPERTIES.reduce((map, property) => {
             map[property.toLowerCase()] = property;
@@ -214,65 +197,28 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             return map;
         }, {});
         const hideDataSourceError = this.hideDatasourceError.bind(this);
-        this.rootEventsListeners.push([gridProGenesisDatasourceEventNames.dataInit, hideDataSourceError], [gridProEventNames.datasourceErrorClose, hideDataSourceError], 
-        // Base datasource error handling for resource validation and initialization errors
-        [baseDatasourceEventNames.error, this.handleBaseDatasourceError.bind(this)], [baseDatasourceEventNames.connected, hideDataSourceError]);
-        this.datasourceEventHandlers = [
-            [datasourceEventNames.initialize, this.handleInitialize.bind(this)],
-            [datasourceEventNames.dataLoaded, this.handleDataLoaded.bind(this)],
-            [datasourceEventNames.dataChanged, this.handleDataChanged.bind(this)],
-            [datasourceEventNames.schemaUpdated, this.handleSchemaUpdated.bind(this)],
-            [datasourceEventNames.dataCleared, this.handleDataCleared.bind(this)],
-            [datasourceEventNames.loadingStarted, this.handleLoadingStarted.bind(this)],
-            [
-                datasourceEventNames.loadingFinished,
-                this.handleLoadingFinished.bind(this),
-            ],
-            [
-                datasourceEventNames.noDataAvailable,
-                this.handleNoDataAvailable.bind(this),
-            ],
-            [
-                datasourceEventNames.filtersRestored,
-                this.handleFiltersRestored.bind(this),
-            ],
-            [
-                datasourceEventNames.moreDataAvailable,
-                this.handleMoreDataAvailable.bind(this),
-            ],
-            [datasourceEventNames.error, this.handleDatasourceError.bind(this)],
-            [datasourceEventNames.destroy, this.handleDatasourceDestroy.bind(this)],
-            [datasourceEventNames.cacheFilterConfig, this.cacheFilterConfig.bind(this)],
-            [
-                datasourceEventNames.refreshServerSide,
-                this.handleRefreshServerSide.bind(this),
-            ],
-            [
-                datasourceEventNames.setServerSideDatasource,
-                this.handleSetServerSideDatasource.bind(this),
-            ],
-            [
-                datasourceEventNames.addGridCssClass,
-                this.handleAddGridCssClass.bind(this),
-            ],
-            [
-                datasourceEventNames.removeGridCssClass,
-                this.handleRemoveGridCssClass.bind(this),
-            ],
-            [
-                datasourceEventNames.applyServerSideTransaction,
-                this.handleApplyServerSideTransaction.bind(this),
-            ],
-            // Infinite Row Model specific events
-            [
-                datasourceEventNames.setInfiniteDatasource,
-                this.handleSetInfiniteDatasource.bind(this),
-            ],
-            [
-                datasourceEventNames.refreshInfiniteCache,
-                this.handleRefreshInfiniteCache.bind(this),
-            ],
-        ];
+        // Bind all event handlers once to ensure proper add/remove of listeners
+        this.eventHandlers.push(
+        // Root event listeners
+        [gridProGenesisDatasourceEventNames.dataInit, hideDataSourceError], [gridProEventNames.datasourceErrorClose, hideDataSourceError], [baseDatasourceEventNames.error, this.handleBaseDatasourceError.bind(this)], [baseDatasourceEventNames.connected, hideDataSourceError], 
+        // Datasource event listeners
+        [datasourceEventNames.initialize, this.handleInitialize.bind(this)], [datasourceEventNames.dataLoaded, this.handleDataLoaded.bind(this)], [datasourceEventNames.dataChanged, this.handleDataChanged.bind(this)], [datasourceEventNames.schemaUpdated, this.handleSchemaUpdated.bind(this)], [datasourceEventNames.dataCleared, this.handleDataCleared.bind(this)], [datasourceEventNames.loadingStarted, this.handleLoadingStarted.bind(this)], [datasourceEventNames.loadingFinished, this.handleLoadingFinished.bind(this)], [datasourceEventNames.noDataAvailable, this.handleNoDataAvailable.bind(this)], [datasourceEventNames.filtersRestored, this.handleFiltersRestored.bind(this)], [datasourceEventNames.moreDataAvailable, this.handleMoreDataAvailable.bind(this)], [datasourceEventNames.error, this.handleDatasourceError.bind(this)], [datasourceEventNames.destroy, this.handleDatasourceDestroy.bind(this)], 
+        // Server-side specific events
+        [datasourceEventNames.cacheFilterConfig, this.cacheFilterConfig.bind(this)], [datasourceEventNames.refreshServerSide, this.handleRefreshServerSide.bind(this)], [datasourceEventNames.setServerSideDatasource, this.handleSetServerSideDatasource.bind(this)], [datasourceEventNames.addGridCssClass, this.handleAddGridCssClass.bind(this)], [datasourceEventNames.removeGridCssClass, this.handleRemoveGridCssClass.bind(this)], [
+            datasourceEventNames.applyServerSideTransaction,
+            this.handleApplyServerSideTransaction.bind(this),
+        ], 
+        // Infinite Row Model events: not supported by this legacy grid (it registers neither the
+        // module nor the handlers). Fail loudly rather than leaving a silently empty grid.
+        [datasourceEventNames.setInfiniteDatasource, this.refuseInfiniteDatasource.bind(this)]);
+    }
+    /**
+     * The Infinite Row Model is only wired into `GridPro` (AG Grid v36), so an infinite datasource placed
+     * inside this element can never load data. Report it instead of ignoring the event.
+     * @internal
+     */
+    refuseInfiniteDatasource() {
+        logger.error('GridProLegacy does not support the Infinite Row Model; use GridPro (AG Grid v36) with grid-pro-infinite-datasource / datasource-type="infinite".');
     }
     /**
      * Adds an event listener to the grid element.
@@ -284,12 +230,14 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     addEventListener(eventType, listener, options) {
         super.addEventListener(eventType, listener, options);
-        if (this.gridApi) {
-            this.addGridEventListener(eventType);
-        }
-        else {
-            if (!this.gridEventsQueue.includes(eventType)) {
-                this.gridEventsQueue.push(eventType);
+        if (ComponentUtil.PUBLIC_EVENTS.includes(eventType)) {
+            if (this.gridApi) {
+                this.addGridEventListener(eventType);
+            }
+            else {
+                if (!this.gridEventsQueue.includes(eventType)) {
+                    this.gridEventsQueue.push(eventType);
+                }
             }
         }
     }
@@ -323,12 +271,8 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         this.removeAttribute('ds-disconnected');
     }
     connectedCallback() {
-        var _a;
         super.connectedCallback();
-        this.syncColumnSelectionHostLayout();
         this.disposed = false;
-        const luminanceTarget = (_a = this.provider) !== null && _a !== void 0 ? _a : this;
-        this.luminanceSubscription = baseLayerLuminance.subscribe(this.luminanceObserver, luminanceTarget);
         if (this.gridAutosizingEnabled) {
             this.visibilityObserverCleanup = respondToVisibility(this, (gridVisible) => {
                 if (gridVisible) {
@@ -337,44 +281,25 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             });
         }
         this.rehydrationAttempted = false;
-        if (!this.shouldRunConnect)
-            return;
-        this.rootEventsListeners.forEach(([eventName, handler]) => {
+        this.eventHandlers.forEach(([eventName, handler]) => {
             this.addEventListener(eventName, handler);
         });
-        // Property reflection for AG Grid properties, so `grid.rowHeight = 40` reaches AG.
-        // A few of these keys are also declared on the component as `@attr` (`headerHeight`,
-        // `rowHeight`), and FAST installs their accessors on the prototype. This shadows those, so
-        // delegate reads and writes to the accessor being covered up — a getter-less own property here
-        // would leave the declared attribute unreadable.
+        if (!this.shouldRunConnect)
+            return;
         AG_PROPERTIES.forEach((key) => {
-            const declared = findDeclaredAccessor(this, key);
             Object.defineProperty(this, key, {
-                get: declared === null || declared === void 0 ? void 0 : declared.get,
                 set: (v) => {
-                    var _a, _b;
-                    const previous = (_a = declared === null || declared === void 0 ? void 0 : declared.get) === null || _a === void 0 ? void 0 : _a.call(this);
-                    (_b = declared === null || declared === void 0 ? void 0 : declared.set) === null || _b === void 0 ? void 0 : _b.call(this, v);
-                    this.agAttributeChangedCallback(convertToKebabCase(key), previous, v);
+                    this.agAttributeChangedCallback(convertToKebabCase(key), undefined, v);
                 },
                 enumerable: true,
                 configurable: true,
             });
         });
-        // Add datasource event listeners
-        this.toggleDatasourceEventListeners(true);
     }
     disconnectedCallback() {
-        var _a;
         this.disposed = true;
         this.debouncedSaveColumnState.cancel();
         this.debouncedSaveFilterModel.cancel();
-        const luminanceTarget = (_a = this.provider) !== null && _a !== void 0 ? _a : this;
-        baseLayerLuminance.unsubscribe(this.luminanceObserver, luminanceTarget);
-        if (this.luminanceSubscription) {
-            this.luminanceSubscription.unsubscribe();
-            this.luminanceSubscription = undefined;
-        }
         if (this.visibilityObserverCleanup) {
             this.visibilityObserverCleanup();
             this.visibilityObserverCleanup = undefined;
@@ -382,10 +307,12 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         super.disconnectedCallback();
         this.rehydrationAttempted = false;
         const shouldRunDisconnect = this.shouldRunDisconnect;
-        this.rootEventsListeners.forEach(([eventName, handler]) => {
+        this.eventHandlers.forEach(([eventName, handler]) => {
             this.removeEventListener(eventName, handler);
         });
         if (!shouldRunDisconnect) {
+            // If lifecycle is temporarily blocked (e.g. layout drag/reconnect path),
+            // still tear down once the element remains detached on the next tick.
             queueMicrotask(() => {
                 if (!this.isConnected) {
                     this.performDisconnectCleanup();
@@ -395,9 +322,6 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         }
         this.performDisconnectCleanup();
     }
-    syncColumnSelectionHostLayout() {
-        this.classList.toggle('has-column-selection', this.enableColumnSelection);
-    }
     performDisconnectCleanup() {
         if (this.debounced) {
             clearTimeout(this.debounced);
@@ -406,19 +330,21 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         this.initialised = false;
         this.resetGridOptionsState();
         this.destroyGridInstance();
-        // Only remove datasource listeners on a real teardown. A blocked (reflow) disconnect must
-        // leave them in place, or a grid that survives the reflow stops reacting to datasource
-        // events (loading/no-rows overlays never update).
-        this.toggleDatasourceEventListeners(false);
         // Destroy can synchronously emit final grid events; cancel again to avoid
         // retaining this element through trailing debounce timers.
         this.debouncedSaveColumnState.cancel();
         this.debouncedSaveFilterModel.cancel();
+        this.invalidateColumnWidthCache();
         // Clear registered events when grid is destroyed
         this.registeredGridEvents.clear();
         this.gridEventsQueue = [];
     }
+    /**
+     * Tear down the AG Grid instance. Prefer {@link GridApi#destroy}; if `gridApi` is not set yet
+     * (e.g. disconnect before `grid-ready`), fall back to {@link Grid#destroy} on the vanilla wrapper.
+     */
     destroyGridInstance() {
+        var _a, _b;
         if (this.gridApi) {
             this.gridEventListeners.forEach((listener, eventType) => {
                 this.gridApi.removeEventListener(eventType, listener);
@@ -426,42 +352,46 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         }
         this.gridEventListeners.clear();
         if (this.gridApi) {
+            // AG Grid's destroy() leaves the client-side row model populated and leaves
+            // scroll/touch listeners on its detached DOM; since the unmounted view is cached
+            // by FAST's `when`, the destroyed grid skeleton stays reachable and would retain
+            // the entire dataset. Clear rows first so only the small skeleton can be retained.
+            if (!this.isServerSide) {
+                try {
+                    (_b = (_a = this.gridApi).flushAsyncTransactions) === null || _b === void 0 ? void 0 : _b.call(_a);
+                    this.gridApi.setRowData([]);
+                }
+                catch (e) {
+                    logger.debug('Grid Pro: failed to clear row data before destroy', e);
+                }
+            }
             this.gridApi.destroy();
         }
         else if (this.agGrid) {
             this.agGrid.destroy();
         }
         if (this.gridSlot) {
-            // Ensure AG Grid internal measurement/theme nodes are removed immediately.
             this.gridSlot.replaceChildren();
         }
         this.gridApi = undefined;
+        this.columnApi = undefined;
         this.agGrid = undefined;
     }
-    /**
-     * Helper method to add or remove datasource event listeners
-     * @internal
-     */
-    toggleDatasourceEventListeners(add) {
-        const method = add ? 'addEventListener' : 'removeEventListener';
-        this.datasourceEventHandlers.forEach(([eventName, handler]) => {
-            // Bypass GridProBeta.addEventListener override: datasource events should not be
-            // mirrored/queued as AG Grid API events.
-            super[method](eventName, handler);
-        });
-    }
     /**
      * Handles datasource initialization
      * @internal
      */
     handleInitialize(event) {
         const { options, keepColDefsOnClearRowData } = event.detail;
+        let columnDefinitions;
         if (keepColDefsOnClearRowData) {
-            this.columnState = this.gridApi.getColumnState();
+            columnDefinitions = this.gridApi.getColumnDefs();
+            this.columnState = this.columnApi.getColumnState();
         }
+        const gridOptions = Object.assign(Object.assign(Object.assign({}, this.userProvidedGridOptions), (columnDefinitions && { columnDefs: columnDefinitions })), options);
         this.applyingDatasourceGridOptions = true;
         try {
-            this.gridOptions = Object.assign(Object.assign(Object.assign({}, this.userProvidedGridOptions), options), (keepColDefsOnClearRowData ? { columnDefs: this.gridApi.getColumnDefs() } : {}));
+            this.gridOptions = Object.assign({}, gridOptions);
             this.initGrid();
         }
         finally {
@@ -475,7 +405,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
     handleDataLoaded(event) {
         const { data } = event.detail;
         if (this.gridApi) {
-            this.gridApi.setGridOption('rowData', data);
+            this.gridApi.setRowData(data);
         }
     }
     /**
@@ -483,25 +413,40 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      * @internal
      */
     handleDataChanged(event) {
+        var _a, _b, _c;
         const { changes } = event.detail;
-        // Every datasource emits this for consumers, but only the client-side row model takes row
-        // transactions: the infinite and server-side datasources drive the grid through
-        // refresh-infinite-cache / apply-server-side-transaction, and applyTransaction on those
-        // models is a no-op that logs an AG Grid warning per event.
-        if (!this.gridApi || !this.isClientSideRowModel)
+        // Every datasource emits this for consumers, but row transactions are a client-side row
+        // model API: the server-side datasource drives the grid through apply-server-side-transaction,
+        // and applyTransaction on that model is a no-op that logs an AG Grid warning per event.
+        if (!this.gridApi || this.isServerSide)
             return;
-        const result = this.gridApi.applyTransaction(changes);
-        this.flashAddedCells(result === null || result === void 0 ? void 0 : result.add);
-    }
-    /**
-     * Whether the live grid runs AG Grid's client-side row model (the default when the datasource
-     * set no `rowModelType`).
-     * @internal
-     */
-    get isClientSideRowModel() {
-        var _a, _b, _c;
-        const rowModelType = (_c = (_b = (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.getGridOption) === null || _b === void 0 ? void 0 : _b.call(_a, 'rowModelType')) !== null && _c !== void 0 ? _c : 'clientSide';
-        return rowModelType === 'clientSide';
+        if (((_a = changes.add) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            if (this.asyncAdd) {
+                this.gridApi.applyTransactionAsync({ add: changes.add, addIndex: this.addIndex }, (result) => {
+                    this.flashAddedCells(result === null || result === void 0 ? void 0 : result.add);
+                });
+            }
+            else {
+                const result = this.gridApi.applyTransaction({ add: changes.add, addIndex: this.addIndex });
+                this.flashAddedCells(result === null || result === void 0 ? void 0 : result.add);
+            }
+        }
+        if (((_b = changes.update) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+            if (this.asyncUpdate) {
+                this.gridApi.applyTransactionAsync({ update: changes.update });
+            }
+            else {
+                this.gridApi.applyTransaction({ update: changes.update });
+            }
+        }
+        if (((_c = changes.remove) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+            if (this.asyncRemove) {
+                this.gridApi.applyTransactionAsync({ remove: changes.remove });
+            }
+            else {
+                this.gridApi.applyTransaction({ remove: changes.remove });
+            }
+        }
     }
     flashAddedCells(rowNodes) {
         if (this.enableRowFlashing && (rowNodes === null || rowNodes === void 0 ? void 0 : rowNodes.length)) {
@@ -514,10 +459,8 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     handleSchemaUpdated(event) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Can fire before `gridApi` is ready (mid-reinit). Unlike rowData — which onGridReady
-            // re-applies from `this.rowData` — the schema has no other home on the instance, so
-            // returning here used to drop it silently and leave the grid with no columns. Stash it
-            // and replay in onGridReady.
+            // Can fire before `gridApi` is ready (mid-reinit). Unlike agAttributes/rowData, the schema
+            // has no other home on the instance, so stash it and replay it in `onGridReady`.
             if (!this.gridApi) {
                 this.pendingSchemaUpdate = event.detail;
                 return;
@@ -526,81 +469,44 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         });
     }
     /**
-     * Builds and applies column defs from a schema payload.
+     * Builds and applies column defs from a schema/metadata payload.
      * @internal
      */
     processSchemaUpdate(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ schema }) {
-            // Only auto-generate columns from the datasource schema when the consumer has NOT already
-            // supplied their own column defs (e.g. via `gridOptions`/`deferredGridOptions.columnDefs` or
-            // `grid-pro-column` templates). Overwriting here would discard user-provided definitions —
-            // including `ColGroupDef` group structure and custom header names — and replace them with flat
-            // metadata columns. This mirrors the stable `GridPro` behaviour.
+        return __awaiter(this, arguments, void 0, function* ({ schema, metadata }) {
             const preSetColumnDefs = this.gridApi.getColumnDefs();
-            if (preSetColumnDefs && preSetColumnDefs.length > 0) {
-                return;
-            }
-            this.applyCommunityFilterFallbacks(schema);
-            // Merge with template definitions
-            const mergedColumnDefs = yield this.mergeAllColumnDefsAndStates(schema, true);
-            this.gridApi.setGridOption('columnDefs', mergedColumnDefs);
-            // Restore the persisted filter model now that the columns exist. The datasource
-            // emits `filtersRestored` synchronously right after `schemaUpdated`, but this handler
-            // is async (it awaits column-state hydration before applying columnDefs), so the
-            // `filtersRestored` restore can run before the columns exist and be silently dropped.
-            // Restoring here guarantees the columns are present for `gridApi.setFilterModel`.
-            this.restoreCachedFilterConfig();
-        });
-    }
-    /**
-     * Downgrades enterprise filters in metadata-generated colDefs when their modules are not
-     * registered — from v35 AG Grid throws on unregistered filters instead of falling back.
-     * Enum columns (recognised by their metadata-sourced set-filter values) keep those values by
-     * falling back to the community `EnumColumnFilter` instead of a plain text filter.
-     *
-     * The enum floating filter is only wired as the column's component, not enabled: AG's floating
-     * filter is a full-width header row, so enabling it for one column changes the layout of every
-     * column. Active-filter state is surfaced instead by AG's native header filter icon plus the
-     * header tooltip the enum filter maintains; consumers wanting the floating row opt in with
-     * `floatingFilter: true`.
-     * @internal
-     */
-    applyCommunityFilterFallbacks(schema) {
-        const hasSetFilter = this.gridApi.isModuleRegistered('SetFilterModule');
-        const hasMultiFilter = this.gridApi.isModuleRegistered('MultiFilterModule');
-        schema.forEach((colDef) => {
-            var _a, _b, _c, _d, _e;
-            if (colDef.filter === 'agSetColumnFilter' && !hasSetFilter) {
-                logger.debug(`SetFilterModule is not registered; column '${colDef.field}' falls back to the enum filter`);
-                colDef.filter = GridProFilterTypes.enumFilter;
-                (_a = colDef.floatingFilterComponent) !== null && _a !== void 0 ? _a : (colDef.floatingFilterComponent = GridProFilterTypes.enumFloatingFilter);
-                return;
-            }
-            if (colDef.filter !== 'agMultiColumnFilter') {
-                return;
-            }
-            const setSubFilter = (_c = (_b = colDef.filterParams) === null || _b === void 0 ? void 0 : _b.filters) === null || _c === void 0 ? void 0 : _c.find((subFilter) => subFilter.filter === 'agSetColumnFilter');
-            if (!hasMultiFilter) {
-                if ((_d = setSubFilter === null || setSubFilter === void 0 ? void 0 : setSubFilter.filterParams) === null || _d === void 0 ? void 0 : _d.values) {
-                    logger.debug(`MultiFilterModule is not registered; enum column '${colDef.field}' falls back to the enum filter`);
-                    colDef.filter = GridProFilterTypes.enumFilter;
-                    // Carry the whole sub-filter config over, not just `values` — a consumer-authored
-                    // multi filter may also set valueFormatter, blanks, etc.
-                    colDef.filterParams = Object.assign({}, setSubFilter.filterParams);
-                    (_e = colDef.floatingFilterComponent) !== null && _e !== void 0 ? _e : (colDef.floatingFilterComponent = GridProFilterTypes.enumFloatingFilter);
-                }
-                else {
-                    logger.warn('MultiFilterModule is not registered, falling back to text filter');
-                    colDef.filter = 'agTextColumnFilter';
+            if (!preSetColumnDefs || preSetColumnDefs.length === 0) {
+                const colDefs = metadata
+                    .map((field) => {
+                    var _a;
+                    return (Object.assign(Object.assign({}, schema.find((colDef) => colDef.field === field.name)), (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.getColumnDef(field.name)));
+                })
+                    .map((colDef) => (Object.assign(Object.assign({}, colDef), { cellRenderer: this.autoCellRendererByType ? colDef.cellRenderer : undefined, cellEditor: this.autoCellRendererByType ? colDef.cellEditor : undefined })));
+                const colDefsMergedWithTemplateDefs = yield this.mergeAllColumnDefsAndStates(colDefs, true);
+                if (colDefsMergedWithTemplateDefs) {
+                    // AG's internals will check if group/pivot are NOT NULL to trigger module registration warning for `row-grouping`.
+                    // When using gridApi to get the currentState to save, all boolean will return false when they were not set at all.
+                    // ColDef type is `boolean` while ColumnState is `boolean | null`.
+                    // `rowGroup`/`pivot` only exist on leaf `ColDef`s, not on `ColGroupDef`s, so skip groups.
+                    colDefsMergedWithTemplateDefs.forEach((col) => {
+                        if ('children' in col) {
+                            return;
+                        }
+                        if (!col.rowGroup) {
+                            col.rowGroup = null;
+                        }
+                        if (!col.pivot) {
+                            col.pivot = null;
+                        }
+                    });
+                    this.gridApi.setColumnDefs(colDefsMergedWithTemplateDefs);
+                    // Restore the persisted filter model now that the columns exist. The datasource
+                    // emits `filtersRestored` synchronously right after `schemaUpdated`, but this handler
+                    // is async (it awaits column-state hydration before `setColumnDefs`), so the
+                    // `filtersRestored` restore can run before the columns exist and be silently dropped.
+                    // Restoring here guarantees the columns are present for `gridApi.setFilterModel`.
+                    this.restoreCachedFilterConfig();
                 }
-                return;
-            }
-            // The multi filter itself is available but its set sub-filter's module is not — opening
-            // the filter would throw AG error #256. The multi filter hosts custom child filters, so
-            // only the nested set filter is swapped for the enum filter (same params, same model).
-            if (!hasSetFilter && setSubFilter) {
-                logger.debug(`SetFilterModule is not registered; the set sub-filter of column '${colDef.field}' falls back to the enum filter`);
-                setSubFilter.filter = GridProFilterTypes.enumFilter;
             }
         });
     }
@@ -609,18 +515,27 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      * @internal
      */
     handleDataCleared(event) {
+        var _a, _b;
         const { includeSchema } = event.detail;
         if (!this.gridApi)
             return;
+        // For server-side, these methods are handled via server-side transactions
+        // Only flush async transactions for client-side row model
+        if (!this.isServerSide) {
+            // Flush any pending async transactions
+            if (this.asyncAdd || this.asyncUpdate || this.asyncRemove) {
+                (_b = (_a = this.gridApi).flushAsyncTransactions) === null || _b === void 0 ? void 0 : _b.call(_a);
+            }
+        }
         if (includeSchema) {
-            this.gridApi.setGridOption('columnDefs', []);
+            this.gridApi.setColumnDefs([]);
         }
-        // rowData belongs to the client-side row model; the infinite and server-side caches are
-        // cleared by their own refresh / transaction events.
-        if (this.isClientSideRowModel) {
-            this.gridApi.setGridOption('rowData', []);
+        // setRowData only works for client-side row model
+        // For server-side, data clearing is handled via server-side transactions
+        if (!this.isServerSide) {
+            this.gridApi.setRowData([]);
+            this.gridApi.refreshCells({ force: true });
         }
-        this.gridApi.refreshCells({ force: true });
     }
     /**
      * Handles loading started from datasource
@@ -628,7 +543,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     handleLoadingStarted() {
         if (this.gridApi) {
-            this.gridApi.setGridOption('loading', true);
+            this.gridApi.showLoadingOverlay();
         }
     }
     /**
@@ -637,7 +552,6 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     handleLoadingFinished() {
         if (this.gridApi) {
-            this.gridApi.setGridOption('loading', false);
             this.gridApi.hideOverlay();
         }
     }
@@ -647,7 +561,6 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     handleNoDataAvailable() {
         if (this.gridApi) {
-            this.gridApi.setGridOption('loading', false);
             this.gridApi.showNoRowsOverlay();
         }
     }
@@ -679,7 +592,8 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      * Handles datasource errors
      * @internal
      */
-    handleDatasourceError() {
+    handleDatasourceError(event) {
+        // Set visual indicator on grid
         this.setAttribute('ds-disconnected', 'ds-disconnected');
     }
     /**
@@ -706,7 +620,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
     handleSetServerSideDatasource(event) {
         const { datasource } = event.detail;
         if (this.gridApi) {
-            this.gridApi.setGridOption('serverSideDatasource', datasource);
+            this.gridApi.setServerSideDatasource(datasource);
         }
     }
     /**
@@ -759,33 +673,6 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             }
         }
     }
-    /**
-     * Handles setting infinite datasource
-     * @internal
-     */
-    handleSetInfiniteDatasource(event) {
-        const { datasource } = event.detail;
-        if (this.gridApi) {
-            this.gridApi.setGridOption('datasource', datasource);
-        }
-    }
-    /**
-     * Handles refreshing the infinite cache.
-     * @remarks Mirrors {@link GridProBeta.handleRefreshServerSide}: `purge` drops the block cache
-     * and re-reads, otherwise the loaded blocks are re-read in place.
-     * @internal
-     */
-    handleRefreshInfiniteCache(event) {
-        var _a;
-        if (!this.gridApi)
-            return;
-        if ((_a = event.detail) === null || _a === void 0 ? void 0 : _a.purge) {
-            this.gridApi.purgeInfiniteCache();
-        }
-        else {
-            this.gridApi.refreshInfiniteCache();
-        }
-    }
     combineAllGridComponents(gridOptionsComponents) {
         const defaultFoundationAgComponents = {
             [GridProRendererTypes.action]: ActionRenderer,
@@ -800,8 +687,6 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             [GridProRendererTypes.multiselectEditor]: MultiselectEditor,
             [GridProRendererTypes.dateEditor]: DateEditor,
             [GridProRendererTypes.stringEditor]: StringEditor,
-            [GridProFilterTypes.enumFilter]: EnumColumnFilter,
-            [GridProFilterTypes.enumFloatingFilter]: EnumColumnFloatingFilter,
             [GridProStatusBarTypes.labelValue]: LabelValueStatusBarComponent,
             [GridProStatusBarTypes.loadMore]: LoadMoreStatusBarComponent,
             [GridProStatusBarTypes.reload]: ReloadStatusBarComponent,
@@ -939,7 +824,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         }, DEBOUNCED_RESIZE_TIME);
     }
     /**
-     * If {@link @genesislcap/grid-pro#GridPro.gridAutosizingEnabled} is true, will remove the widths from the column states.
+     * If {@link @genesislcap/grid-pro#GridProLegacy.gridAutosizingEnabled} is true, will remove the widths from the column states.
      * @internal
      */
     removeConfigWidthsToAutosize(colState) {
@@ -948,7 +833,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
     saveColumnState() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.rehydrationAttempted && this.statePersistanceEnabled()) {
-                let colState = this.gridApi.getColumnState();
+                let colState = this.columnApi.getColumnState();
                 colState = sanitizeColumnState(colState);
                 colState = this.gridAutosizingEnabled
                     ? this.removeConfigWidthsToAutosize(colState)
@@ -956,7 +841,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                 const allHeadersHidden = colState.filter((c) => {
                     if (c.hide)
                         return false;
-                    const col = this.gridApi.getColumn(c.colId);
+                    const col = this.columnApi.getColumn(c.colId);
                     return Boolean(col.getColDef().headerName);
                 }).length === 0;
                 if (colState.length === 0 ||
@@ -978,11 +863,40 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         return __awaiter(this, void 0, void 0, function* () {
             this.columnState = [];
             if (this.statePersistanceEnabled()) {
-                this.columnState = (yield this.statePersistence.getColumnState(this.persistColumnStateKey));
+                this.columnState = yield this.statePersistence.getColumnState(this.persistColumnStateKey);
             }
             return this.columnState;
         });
     }
+    /**
+     * Deletes the saved column state for the current grid
+     * @param resetToDefault - Whether to reset columns to their default configuration. Defaults to true.
+     * @remarks This removes the persisted column state from storage, allowing the grid to use default column configuration
+     * @public
+     */
+    deleteColumnState() {
+        return __awaiter(this, arguments, void 0, function* (resetToDefault = true) {
+            var _a;
+            if (this.statePersistanceEnabled()) {
+                yield this.statePersistence.deleteColumnState(this.persistColumnStateKey);
+                this.columnState = [];
+            }
+            if (resetToDefault && this.columnApi) {
+                if (((_a = this.defaultColumnConfig) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                    // Convert ColDef[] to ColumnState[] using utility function
+                    const columnState = convertColDefsToColumnStates(this.defaultColumnConfig);
+                    this.columnApi.applyColumnState({
+                        state: columnState,
+                        applyOrder: true,
+                    });
+                }
+                else {
+                    this.columnApi.resetColumnState();
+                }
+                this.handleColumnSizing();
+            }
+        });
+    }
     restoreColumnState() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -990,7 +904,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             const colState = yield this.getSavedColumnState();
             const sanitizedColState = sanitizeColumnState(colState);
             if (sanitizedColState && sanitizedColState.length > 0) {
-                (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.applyColumnState({
+                (_a = this.columnApi) === null || _a === void 0 ? void 0 : _a.applyColumnState({
                     state: sanitizedColState,
                     applyOrder: true,
                 });
@@ -1028,8 +942,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
      */
     get gridParams() {
         return {
-            globalListener: this.boundGlobalEventListener,
-            modules: [gridProColumnDragBridgeModule, ColumnMoveModule, DragAndDropModule],
+            globalEventListener: this.boundGlobalEventListener,
         };
     }
     /**
@@ -1040,14 +953,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
     get gridProDatasource() {
         return (this.querySelector('grid-pro-genesis-datasource') ||
             this.querySelector('grid-pro-client-side-datasource') ||
-            this.querySelector('grid-pro-server-side-datasource') ||
-            this.querySelector('grid-pro-infinite-datasource'));
-    }
-    /**
-     * @public
-     */
-    get isInfiniteRowModel() {
-        return this.gridProDatasource instanceof GridProInfiniteDatasource;
+            this.querySelector('grid-pro-server-side-datasource'));
     }
     /**
      * Reports the currently visible columns to the datasource. The datasource decides what to do with
@@ -1059,9 +965,9 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         const datasource = this.gridProDatasource;
         if (!datasource)
             return;
-        const visibleFields = resolveVisibleColumnFields((_b = (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.getAllDisplayedColumns) === null || _b === void 0 ? void 0 : _b.call(_a), (_d = (_c = this.gridApi) === null || _c === void 0 ? void 0 : _c.getColumnDefs) === null || _d === void 0 ? void 0 : _d.call(_c));
+        const visibleFields = resolveVisibleColumnFields((_b = (_a = this.columnApi) === null || _a === void 0 ? void 0 : _a.getAllDisplayedColumns) === null || _b === void 0 ? void 0 : _b.call(_a), (_d = (_c = this.gridApi) === null || _c === void 0 ? void 0 : _c.getColumnDefs) === null || _d === void 0 ? void 0 : _d.call(_c));
         // Skip empty results so we never overwrite a known visible set with nothing (e.g. when the
-        // grid API/defs aren't populated yet during early lifecycle).
+        // column API/defs aren't populated yet during early lifecycle).
         if (!visibleFields.length)
             return;
         datasource.setVisibleColumns(visibleFields);
@@ -1078,52 +984,45 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                 return;
             this.debouncedSaveColumnState();
             this.debouncedColumnAutosize();
+            this.invalidateColumnWidthCache();
         };
         const notifyVisibilityChanged = () => {
             if (this.disposed || !this.isConnected)
                 return;
             this.debouncedNotifyDatasourceVisibleColumns();
         };
-        // Collect attributes and map them to AG Grid properties
         Array.from(this.attributes).forEach((attribute) => {
             const attrName = this.agPropertiesMap[attribute.name];
             if (!attrName)
                 return;
             this.agAttributes[attrName] = attribute.value;
         });
-        const { columnDefs, components, defaultColDef, getRowId, onGridReady, onFilterChanged, onFirstDataRendered } = options, rest = __rest(options, ["columnDefs", "components", "defaultColDef", "getRowId", "onGridReady", "onFilterChanged", "onFirstDataRendered"]);
-        const derivedOptions = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, this.gridOptionsConfig), { defaultColDef: Object.assign({ enableCellChangeFlash: this.enableCellFlashing, filter: true, resizable: true, sortable: true }, defaultColDef), components: this.combineAllGridComponents(components), headerHeight: this.headerHeight, rowHeight: this.rowHeight, animateRows: false, suppressDragLeaveHidesColumns: true }), this.eventsAndCallbacks), { onGridReady: (event) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c;
+        const _a = options, { columnDefs, components, defaultColDef, getRowId, onGridReady, onFilterChanged, onFirstDataRendered } = _a, rest = __rest(_a, ["columnDefs", "components", "defaultColDef", "getRowId", "onGridReady", "onFilterChanged", "onFirstDataRendered"]);
+        const gridOptionsConfig = this.gridOptionsConfig;
+        const derivedOptions = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, gridOptionsConfig), { defaultColDef: Object.assign({ enableCellChangeFlash: this.enableCellFlashing, filter: true, resizable: true, sortable: true }, defaultColDef), components: this.combineAllGridComponents(components), suppressDragLeaveHidesColumns: true }), this.eventsAndCallbacks), { onGridReady: (event) => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
                 this.gridApi = event.api;
+                this.columnApi = event.columnApi;
                 if (this.gridEventsQueue.length) {
                     this.gridEventsQueue.forEach((type) => {
                         this.addGridEventListener(type);
                     });
                 }
-                // Awaited so the columns land before rowData/columnState below — otherwise they
-                // would race against an empty column model. Caught because ag-grid neither awaits
-                // nor handles this callback's promise: a rejection (mergeAllColumnDefsAndStates
-                // hydrates column state) would surface as an unhandled rejection AND skip the rest
-                // of init — rowData, the consumer's onGridReady, the grid-ready emit. A grid with
-                // no columns beats one that never finishes starting.
+                // Await so columns land before rowData/columnState/ready below - otherwise they'd
+                // race against an empty column model.
                 if (this.pendingSchemaUpdate) {
                     const pendingSchemaUpdate = this.pendingSchemaUpdate;
                     this.pendingSchemaUpdate = undefined;
-                    try {
-                        yield this.processSchemaUpdate(pendingSchemaUpdate);
-                    }
-                    catch (error) {
-                        logger.error('Grid Pro: failed to apply the pending schema update on grid ready:', error);
-                    }
+                    yield this.processSchemaUpdate(pendingSchemaUpdate);
                 }
                 if (this.rowData) {
-                    this.gridApi.setGridOption('rowData', this.rowData);
+                    this.gridApi.setRowData(this.rowData);
                 }
                 if (onGridReady) {
                     onGridReady(event);
                 }
-                if (((_a = this.gridProDatasource) === null || _a === void 0 ? void 0 : _a.keepColDefsOnClearRowData) && ((_b = this.columnState) === null || _b === void 0 ? void 0 : _b.length) > 0) {
-                    this.gridApi.applyColumnState({
+                if (this.columnState && ((_a = this.columnState) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                    this.columnApi.applyColumnState({
                         state: this.columnState,
                         applyOrder: true,
                     });
@@ -1140,16 +1039,20 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                 // Seed the datasource with the initially visible columns before the load is kicked off, so
                 // a datasource that scopes its request to visible columns can narrow the first request.
                 this.notifyDatasourceVisibleColumns();
+                // Emit datasource ready event, signals that the datasource is ready to be used
                 // TODO: prevent rendering datasource slot until grid is ready
                 // so there is no need for this even and handling it in datasources
-                (_c = this.gridProDatasource) === null || _c === void 0 ? void 0 : _c.$emit(datasourceEventNames.ready);
+                (_b = this.gridProDatasource) === null || _b === void 0 ? void 0 : _b.$emit(datasourceEventNames.ready);
                 this.restoreColumnState();
                 this.restoreCachedFilterConfig();
                 this.debouncedColumnAutosize();
             }), onFirstDataRendered: (event) => {
-                // Safety net: by now the grid columns are populated, so (re)seed the datasource's visible
+                // Handle column sizing
+                this.handleColumnSizing();
+                // Safety net: by now the column API is populated, so (re)seed the datasource's visible
                 // columns in case the initial grid-ready seed ran before columns were available.
                 this.notifyDatasourceVisibleColumns();
+                // Call the original onFirstDataRendered if provided
                 if (onFirstDataRendered) {
                     onFirstDataRendered(event);
                 }
@@ -1174,9 +1077,12 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                     onFilterChanged(filterChangedEvent);
                 }
             }, onGridSizeChanged: gridOnChangeCallback, onSortChanged: gridOnChangeCallback }), rest);
+        const hasGetRowId = 'getRowId' in (options !== null && options !== void 0 ? options : {});
         if (this.gridProDatasource) {
             derivedOptions.columnDefs = columnDefs;
-            derivedOptions.getRowId = getRowId;
+            if (hasGetRowId) {
+                derivedOptions.getRowId = getRowId;
+            }
             this.setupStatusBar(derivedOptions);
             this.setLocalGridOptions(derivedOptions);
         }
@@ -1186,7 +1092,9 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                     return;
                 }
                 derivedOptions.columnDefs = value;
-                derivedOptions.getRowId = getRowId;
+                if (hasGetRowId) {
+                    derivedOptions.getRowId = getRowId;
+                }
                 this.setupStatusBar(derivedOptions);
                 this.setLocalGridOptions(derivedOptions);
                 this.initGrid();
@@ -1194,12 +1102,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         }
     }
     setLocalGridOptions(derivedOptions) {
-        // Merge options with reflected AG properties from attributes
         this.agGridOptions = Object.assign(Object.assign({}, this.agGridOptions), copyAttributesToGridOptions(derivedOptions, this.agAttributes));
-        this.agGridOptions.context = Object.assign(Object.assign({}, this.agGridOptions.context), { [GRID_PRO_COLUMN_DRAG_BRIDGE_CONTEXT_KEY]: this.columnDragBridge });
-        if (this.agGridOptions.allowDragFromColumnsToolPanel == null) {
-            this.agGridOptions.allowDragFromColumnsToolPanel = true;
-        }
     }
     /**
      * Clears the local grid options, this is used to clear the grid options when the grid is restarted.
@@ -1208,17 +1111,25 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
     clearLocalGridOptions() {
         this.agGridOptions = undefined;
     }
+    /**
+     * Clears all grid option state when the grid element is fully torn down.
+     * @internal
+     */
     resetGridOptionsState() {
         this.userProvidedGridOptions = undefined;
         this.agGridOptions = undefined;
     }
     initGrid() {
         DOM.queueUpdate(() => {
-            // `gridSlot` is a template ref, so it is undefined until the view binds, and this task runs
-            // on the shared update queue — an options change can queue it ahead of that binding. Reading
-            // `.firstChild` off it unguarded then throws from INSIDE a queued task, which the runner can
-            // only report against whichever test is running. Same guard as `grid-pro.ts`; both callers
-            // re-run on the next grid-options change, so skipping strands nothing.
+            // `gridSlot` belongs in this readiness check, not just `disposed`/`isConnected`: it is a
+            // template ref, so it is undefined until the view binds, and this task runs on the shared
+            // update queue — an options change can queue it ahead of the binding that fills the ref.
+            // Every other reader in this file already guards it; these two lines did not, so that
+            // ordering threw `Cannot read properties of undefined (reading 'firstChild')` from INSIDE a
+            // queued task. Such a throw is not attributable to whatever caused it: web-test-runner
+            // reports it as an uncaught page exception against whichever test happens to be running,
+            // which is how it surfaced — as an unrelated datasource test failing only under CI load.
+            // Skipping is safe because both callers re-run on the next grid-options change.
             if (this.disposed || !this.isConnected || !this.gridSlot) {
                 return;
             }
@@ -1230,10 +1141,21 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                     this.gridSlot.removeChild(this.gridSlot.firstChild);
                 }
             }
-            this.agGrid = createGrid(this.gridSlot, this.agGridOptions, this.gridParams);
+            this.agGrid = new Grid(this.gridSlot, this.agGridOptions, this.gridParams);
             this.initialised = true;
         });
     }
+    /**
+     * Will merge templated column definitions with `columnDefs` plus localStorage's column state or `deferredColumnStates`.
+     * @deprecated use `applyTemplateDefinitions` instead.
+     * @param columnDefs - The column definitions to apply to the grid.
+     * @param deferredColumnDefsOrState - If true, will merge the column definitions with the saved column state or the `deferredColumnStates` property on the `grid-pro-genesis-datasource` element.
+     * @returns The merged column definitions.
+     */
+    applyTemplateDefinitions(columnDefs, deferredColumnDefsOrState = false) {
+        logger.deprecated('applyTemplateDefinitions', 'Use `mergeAllColumnDefsAndStates` instead.');
+        return this.mergeAllColumnDefsAndStates(columnDefs, deferredColumnDefsOrState);
+    }
     /**
      * Will merge templated column definitions with `columnDefs` plus localStorage's column state or `deferredColumnStates`.
      * @public
@@ -1261,7 +1183,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             const templateColumnDefs = Array.from(this.querySelectorAll(this.columnComponentName))
                 .map((templateColumn) => templateColumn.definition)
                 .map((columnDef) => {
-                var _a, _b, _c, _d, _e, _f;
+                var _a, _b;
                 // enable cell flashing for each column if unspecified on column level but enabled on grid level
                 if (this.enableCellFlashing && columnDef.enableCellChangeFlash === undefined) {
                     columnDef.enableCellChangeFlash = true;
@@ -1272,25 +1194,21 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                  * respect that choice and don't inject metadata values. This allows consumers to
                  * opt out of metadata values and let AG Grid extract values from row data instead.
                  */
-                if (columnDef.filter === 'agSetColumnFilter' ||
-                    columnDef.filter === GridProFilterTypes.enumFilter) {
+                if (columnDef.filter === 'agSetColumnFilter') {
                     const hasExplicitValues = columnDef.filterParams != null && 'values' in columnDef.filterParams;
                     if (!hasExplicitValues) {
-                        const metadataFilterParams = (_a = columnDefinitionsFromMetadata.find((colDef) => colDef.field === columnDef.field)) === null || _a === void 0 ? void 0 : _a.filterParams;
-                        // Metadata enum values are flat ({ values }) on the server-side datasource path, but
-                        // nested inside a multi-filter's set sub-filter on the client-side datasource path.
-                        const metadataValues = (_b = metadataFilterParams === null || metadataFilterParams === void 0 ? void 0 : metadataFilterParams.values) !== null && _b !== void 0 ? _b : (_e = (_d = (_c = metadataFilterParams === null || metadataFilterParams === void 0 ? void 0 : metadataFilterParams.filters) === null || _c === void 0 ? void 0 : _c.find((subFilter) => subFilter.filter === 'agSetColumnFilter')) === null || _d === void 0 ? void 0 : _d.filterParams) === null || _e === void 0 ? void 0 : _e.values;
+                        const metadataValues = (_b = (_a = columnDefinitionsFromMetadata.find((colDef) => colDef.field === columnDef.field)) === null || _a === void 0 ? void 0 : _a.filterParams) === null || _b === void 0 ? void 0 : _b.values;
                         if (metadataValues) {
                             columnDef.filterParams = Object.assign(Object.assign({}, columnDef.filterParams), { values: metadataValues });
                         }
                     }
-                    if (columnDef.filter === GridProFilterTypes.enumFilter) {
-                        (_f = columnDef.floatingFilterComponent) !== null && _f !== void 0 ? _f : (columnDef.floatingFilterComponent = GridProFilterTypes.enumFloatingFilter);
-                    }
                 }
                 if (columnDef.editable) {
                     if (!columnDef.cellRenderer && !columnDef.cellRendererSelector) {
                         columnDef.cellRendererSelector = (params) => {
+                            if (!(params === null || params === void 0 ? void 0 : params.data)) {
+                                return undefined;
+                            }
                             if (params.data[EDITED_COLUMN_FIELD] === columnDef.field) {
                                 return {
                                     component: GridProRendererTypes.editable,
@@ -1301,6 +1219,9 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                     if (!columnDef.tooltipComponent && !columnDef.tooltipValueGetter) {
                         columnDef.tooltipComponent = ErrorTooltip;
                         columnDef.tooltipValueGetter = (params) => {
+                            if (!(params === null || params === void 0 ? void 0 : params.data)) {
+                                return undefined;
+                            }
                             const error = params.data[ERROR_COLUMN_FIELD];
                             if (error && error.column === columnDef.field) {
                                 return error.message;
@@ -1309,7 +1230,13 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
                     }
                     if (!columnDef.cellClassRules) {
                         columnDef.cellClassRules = {
-                            error: (params) => { var _a; return ((_a = params.data[ERROR_COLUMN_FIELD]) === null || _a === void 0 ? void 0 : _a.column) === params.colDef.field; },
+                            error: (params) => {
+                                var _a;
+                                if (!(params === null || params === void 0 ? void 0 : params.colDef) || !(params === null || params === void 0 ? void 0 : params.data)) {
+                                    return false;
+                                }
+                                return ((_a = params.data[ERROR_COLUMN_FIELD]) === null || _a === void 0 ? void 0 : _a.column) === params.colDef.field;
+                            },
                         };
                     }
                 }
@@ -1342,13 +1269,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         // The custom rowCount panel is used for server-side infinite scroll (load more) scenarios;
         // client-side row models use AG Grid's own row count component instead.
         if (this.statusBarConfig && this.statusBarConfig.rows === true) {
-            // Check the derived gridOptions parameter, not this.gridOptions: setupStatusBar runs
-            // before setLocalGridOptions populates the field, so on first init the field is still
-            // undefined and a standalone grid's rowModelType would be missed.
-            const isServerSide = this.isServerSide ||
-                this.isInfiniteRowModel ||
-                (gridOptions === null || gridOptions === void 0 ? void 0 : gridOptions.rowModelType) === 'infinite' ||
-                (gridOptions === null || gridOptions === void 0 ? void 0 : gridOptions.rowModelType) === 'serverSide';
+            const isServerSide = this.isServerSide || (gridOptions === null || gridOptions === void 0 ? void 0 : gridOptions.rowModelType) === 'serverSide';
             if (isServerSide) {
                 if (!this.panelExists(GridProStatusBarTypes.rowCount, statusPanels)) {
                     statusPanels.push({
@@ -1395,9 +1316,7 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
     }
     addDatasourcePanels(statusPanels) {
         if (this.gridProDatasource) {
-            // The infinite row model loads on scroll, so its loadMore() is a no-op: suppress the
-            // Load More panel for it the same way it is suppressed for the server-side row model.
-            const datasourceStatusPanels = this.gridProDatasource.getDatasourceStatusBarPanels(this.isServerSide || this.isInfiniteRowModel, this.statusBarConfig);
+            const datasourceStatusPanels = this.gridProDatasource.getDatasourceStatusBarPanels(this.isServerSide, this.statusBarConfig);
             // Filter out duplicate datasource panels
             const newDatasourcePanels = datasourceStatusPanels.filter((panel) => !this.panelExists(panel.statusPanel, statusPanels));
             statusPanels.push(...newDatasourcePanels);
@@ -1425,6 +1344,94 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             };
         }
     }
+    /**
+     * Handles column sizing based on sizeColumnsToContent and sizeColumnsToFit attributes
+     * @private
+     */
+    handleColumnSizing() {
+        if (!this.sizeColumnsToContent && !this.sizeColumnsToFit)
+            return;
+        if (this.sizeColumnsToContent && this.sizeColumnsToFit && this.columnApi && this.gridApi) {
+            this.handleBothSizingModes();
+        }
+        else {
+            this.handleIndividualSizingModes();
+        }
+    }
+    /**
+     * Handles when both sizeColumnsToContent and sizeColumnsToFit are enabled
+     * @private
+     */
+    handleBothSizingModes() {
+        const totalColumnWidth = this.calculateTotalColumnWidth();
+        const gridWidth = this.getGridWidth();
+        if (totalColumnWidth > gridWidth) {
+            if (!this.columnApi)
+                return;
+            this.columnApi.autoSizeAllColumns();
+        }
+        else {
+            if (!this.gridApi)
+                return;
+            this.gridApi.sizeColumnsToFit();
+        }
+    }
+    /**
+     * Handles individual sizing modes when only one is enabled
+     * @private
+     */
+    handleIndividualSizingModes() {
+        if (this.sizeColumnsToContent && this.columnApi) {
+            this.columnApi.autoSizeAllColumns();
+        }
+        if (this.sizeColumnsToFit && this.gridApi) {
+            this.gridApi.sizeColumnsToFit();
+        }
+    }
+    /**
+     * Calculates the total width of all columns
+     * @private
+     */
+    calculateTotalColumnWidth() {
+        if (!this.columnApi) {
+            return 0;
+        }
+        const allColumns = this.columnApi.getAllGridColumns();
+        const currentColumnCount = allColumns.length;
+        // Check if cache is still valid (same number of columns)
+        if (this.cachedTotalColumnWidth !== null && this.columnCount === currentColumnCount) {
+            return this.cachedTotalColumnWidth;
+        }
+        // Calculate and cache the total width
+        this.cachedTotalColumnWidth = allColumns.reduce((sum, col) => sum + (col.getActualWidth() || 0), 0);
+        this.columnCount = currentColumnCount;
+        return this.cachedTotalColumnWidth;
+    }
+    /**
+     * Invalidates the cached column width calculation
+     * @private
+     * @remarks This method is called automatically when column changes occur (resize, move, pin, etc.)
+     * to ensure the cached width calculation remains accurate.
+     */
+    invalidateColumnWidthCache() {
+        this.cachedTotalColumnWidth = null;
+        this.columnCount = 0;
+    }
+    /**
+     * Gets the available grid width with fallbacks
+     * @private
+     */
+    getGridWidth() {
+        const gridElement = this;
+        let gridWidth = (gridElement === null || gridElement === void 0 ? void 0 : gridElement.clientWidth) || 0;
+        if (gridWidth === 0 && this.gridSlot) {
+            gridWidth = this.gridSlot.clientWidth || 0;
+        }
+        if (gridWidth === 0) {
+            gridWidth = this.clientWidth || 0;
+        }
+        return gridWidth;
+    }
     get observedAttributes() {
         // allow properties to be supplied either lowercased or kebab-cased
         // this allows the user to either supply (for example) enableSorting or enabled-sorting
@@ -1435,7 +1442,6 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         return lowerCasedPropertyNames.concat(kebabCasePropertyNames);
     }
     agAttributeChangedCallback(attName, oldValue, newValue) {
-        var _a;
         if (oldValue === newValue) {
             return;
         }
@@ -1443,9 +1449,13 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
         if (gridPropertyName) {
             // for properties set before gridOptions is called
             this.agAttributes[gridPropertyName] = newValue;
-            if (this.initialised) {
-                // for subsequent (post gridOptions) changes - use setGridOption API for v35
-                (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.setGridOption(gridPropertyName, newValue);
+            // `initialised` flips true before `gridApi` is assigned (mid-reinit), so relying on it
+            // alone here can crash processOnChange with an undefined api.
+            if (this.initialised && this.gridApi) {
+                // for subsequent (post gridOptions) changes
+                const changeObject = {};
+                changeObject[gridPropertyName] = { currentValue: newValue };
+                ComponentUtil.processOnChange(changeObject, this.gridApi);
             }
         }
     }
@@ -1462,85 +1472,136 @@ export class GridProBeta extends LifecycleMixin(FoundationElement) {
             this[callbackMethod](browserEvent);
         }
     }
+    insertFontFace(newValue) {
+        const fontFaceRule = agThemeFontFaceMap[newValue] || this.gridFontFace;
+        this.destroyFontFace();
+        const newDestroy = insertDocumentCSSRule(fontFaceRule, agThemeFontsId(newValue));
+        if (newDestroy) {
+            this.fontFaceDestroy = newDestroy;
+        }
+    }
+    destroyFontFace() {
+        if (this.fontFaceDestroy) {
+            this.fontFaceDestroy();
+            this.fontFaceDestroy = null;
+        }
+    }
 }
 __decorate([
     observable
-], GridProBeta.prototype, "gridApi", void 0);
+], GridProLegacy.prototype, "columnApi", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "gridErrorItems", void 0);
+], GridProLegacy.prototype, "gridApi", void 0);
+__decorate([
+    observable
+], GridProLegacy.prototype, "gridErrorItems", void 0);
 __decorate([
     StatePersistence
-], GridProBeta.prototype, "statePersistence", void 0);
+], GridProLegacy.prototype, "statePersistence", void 0);
 __decorate([
     attr({ attribute: 'auto-cell-renderer-by-type', mode: 'boolean' })
-], GridProBeta.prototype, "autoCellRendererByType", void 0);
+], GridProLegacy.prototype, "autoCellRendererByType", void 0);
 __decorate([
     attr({ attribute: 'only-template-col-defs', mode: 'boolean' })
-], GridProBeta.prototype, "onlyTemplateColDefs", void 0);
+], GridProLegacy.prototype, "onlyTemplateColDefs", void 0);
 __decorate([
     attr({ mode: 'boolean', attribute: 'grid-autosizing' })
-], GridProBeta.prototype, "gridAutosizingEnabled", void 0);
+], GridProLegacy.prototype, "gridAutosizingEnabled", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'size-columns-to-content' })
+], GridProLegacy.prototype, "sizeColumnsToContent", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'size-columns-to-fit' })
+], GridProLegacy.prototype, "sizeColumnsToFit", void 0);
+__decorate([
+    attr({ attribute: 'add-index' })
+], GridProLegacy.prototype, "addIndex", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'async-add' })
+], GridProLegacy.prototype, "asyncAdd", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'async-remove' })
+], GridProLegacy.prototype, "asyncRemove", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'async-update' })
+], GridProLegacy.prototype, "asyncUpdate", void 0);
 __decorate([
     attr({ mode: 'boolean', attribute: 'enable-cell-flashing' })
-], GridProBeta.prototype, "enableCellFlashing", void 0);
+], GridProLegacy.prototype, "enableCellFlashing", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'enabled-row-flashing' })
+], GridProLegacy.prototype, "enabledRowFlashing", void 0);
 __decorate([
     attr({ mode: 'boolean', attribute: 'enable-row-flashing' })
-], GridProBeta.prototype, "enableRowFlashing", void 0);
+], GridProLegacy.prototype, "enableRowFlashing", void 0);
 __decorate([
     attr({ attribute: 'persist-column-state-key' })
-], GridProBeta.prototype, "persistColumnStateKey", void 0);
+], GridProLegacy.prototype, "persistColumnStateKey", void 0);
 __decorate([
     attr({ attribute: 'persist-filter-model-key' })
-], GridProBeta.prototype, "persistFilterModelKey", void 0);
+], GridProLegacy.prototype, "persistFilterModelKey", void 0);
+__decorate([
+    attr({ attribute: 'default-column-config' })
+], GridProLegacy.prototype, "defaultColumnConfig", void 0);
 __decorate([
     attr({ attribute: 'header-case-type' })
-], GridProBeta.prototype, "headerCaseType", void 0);
+], GridProLegacy.prototype, "headerCaseType", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "rowData", void 0);
+], GridProLegacy.prototype, "rowData", void 0);
+__decorate([
+    observable
+], GridProLegacy.prototype, "gridFontFace", void 0);
 __decorate([
     attr
-], GridProBeta.prototype, "columnComponentName", void 0);
+], GridProLegacy.prototype, "columnComponentName", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "eventsAndCallbacks", void 0);
+], GridProLegacy.prototype, "eventsAndCallbacks", void 0);
+__decorate([
+    attr
+], GridProLegacy.prototype, "headerHeight", void 0);
 __decorate([
     attr
-], GridProBeta.prototype, "headerHeight", void 0);
+], GridProLegacy.prototype, "rowHeight", void 0);
 __decorate([
     attr
-], GridProBeta.prototype, "rowHeight", void 0);
+], GridProLegacy.prototype, "theme", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "classNames", void 0);
+], GridProLegacy.prototype, "classNames", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "agGrid", void 0);
+], GridProLegacy.prototype, "agGrid", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "gridSlot", void 0);
+], GridProLegacy.prototype, "gridSlot", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "themeMode", void 0);
+], GridProLegacy.prototype, "themeMode", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "gridComponents", void 0);
+], GridProLegacy.prototype, "gridComponents", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "statusBarConfig", void 0);
+], GridProLegacy.prototype, "statusBarConfig", void 0);
 __decorate([
     attr({ mode: 'boolean', attribute: 'with-status-bar' })
-], GridProBeta.prototype, "withStatusBar", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'enable-column-selection' })
-], GridProBeta.prototype, "enableColumnSelection", void 0);
+], GridProLegacy.prototype, "withStatusBar", void 0);
 __decorate([
     observable
-], GridProBeta.prototype, "customErrorHandlerTemplate", void 0);
+], GridProLegacy.prototype, "customErrorHandlerTemplate", void 0);
 __decorate([
     GridOptionsConfig
-], GridProBeta.prototype, "gridOptionsConfig", void 0);
-__decorate([
-    observable
-], GridProBeta.prototype, "provider", void 0);
+], GridProLegacy.prototype, "gridOptionsConfig", void 0);
+/**
+ * A function that returns a Foundation Grid Pro Legacy registration for configuring the component with a DesignSystem.
+ *
+ * @public
+ * @deprecated Legacy AG Grid v29 wrapper. Use `GridPro` (AG Grid v36) instead.
+ * @remarks
+ * HTML Element: \<foundation-grid-pro\>
+ */
+export const foundationGridProLegacy = GridProLegacy.compose(Object.assign({ baseName: 'grid-pro', styles,
+    template, shadowOptions: foundationGridProShadowOptions }, defaultGridProConfig));