@genesislcap/grid-pro 15.35.1 → 16.0.0

package/dist/esm/grid-pro.js

@@ -1,63 +1,113 @@
 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, insertDocumentCSSRule, LifecycleMixin, respondToVisibility, } from '@genesislcap/foundation-utils';
-import { attr, DOM, observable } from '@microsoft/fast-element';
+import { avoidTreeShaking, LifecycleMixin, respondToVisibility, } from '@genesislcap/foundation-utils';
+import { baseLayerLuminance, StandardLuminance } from '@microsoft/fast-components';
+import { attr, css, DOM, observable } from '@microsoft/fast-element';
 import { FoundationElement } from '@microsoft/fast-foundation';
-import { classNames } from '@microsoft/fast-web-utilities';
+import { CellApiModule, 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 * 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 { GridProClientSideDatasource, GridProServerSideDatasource } from './datasource';
+import { EnumColumnFilter, EnumColumnFloatingFilter, GridProFilterTypes } from './column-filters';
+import { ColumnSelection, gridProColumnSelectionHostStyles } 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 { baseDatasourceEventNames } from './datasource/base.types';
-import { agThemeFontFaceMap, defaultAgGridFontFace } from './external';
+import { errorHandlerDialogStyles } from './datasource/error-handler.dialog';
 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 { foundationGridProStyles as styles } from './grid-pro.styles';
+import { AG_PROPERTIES, copyAttributesToGridOptions, DEBOUNCED_RESIZE_TIME, defaultGridProConfig, foundationGridProShadowOptions, gridProErrorNames, gridProEventNames, } from './grid-pro.definitions';
+import { agDragGhostShadowDomStyles, rowMatchAlertStyles } 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 { 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 { convertColDefsToColumnStates, convertToKebabCase, logger, mergeAndDedupColDefWithColumnState, sanitizeColumnState, } from './utils';
-avoidTreeShaking(GridProGenesisDatasource, GridProClientSideDatasource, GridProServerSideDatasource, GridProCell, GridProColumn);
-ModuleRegistry.registerModules([CsvExportModule, ClientSideRowModelModule]);
+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,
+    // `gridApi.getCellValue` (used by consumers that read edited rows back, e.g. entity-management)
+    CellApiModule,
+    NumberFilterModule,
+    CellStyleModule,
+    DateFilterModule,
+    RowApiModule,
+    TooltipModule,
+    ColumnAutoSizeModule,
+    RenderApiModule,
+    RowDragModule,
+    RowSelectionModule,
+    CustomEditorModule,
+    TextEditorModule,
+    NumberEditorModule,
+    DateEditorModule,
+    SelectEditorModule,
+    CheckboxEditorModule,
+    CustomFilterModule,
+    InfiniteRowModelModule,
+    DragAndDropModule,
+    ColumnMoveModule,
+    gridProColumnDragBridgeModule,
+    // ValidationModule,
+]);
 const DEBOUNCE_TIME = 400;
-// Re-export AG_PROPERTIES from definitions for backwards compatibility
-export { AG_PROPERTIES };
+const Events = {
+    EVENT_GRID_READY: 'gridReady',
+};
+/**
+ * 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.
+ * The Grid Pro element (AG Grid v36 compatible).
  * @remarks Grid Pro is a Web Component wrapper around the AG Grid Community library.
  * @public
  * @tagname %%prefix%%-grid-pro
  *
- * @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 - 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 - 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 `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', ...)`).
+ * @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', ...)`).
  */
 export class GridPro extends LifecycleMixin(FoundationElement) {
+    /** @internal Shared AG column-drag bridge for custom tool panels. */
+    getColumnDragBridge() {
+        return this.columnDragBridge;
+    }
     rowDataChanged(_, rowData) {
-        // `initialised` flips true before `gridApi` is assigned (mid-reinit), so relying on it
-        // alone here can crash setRowData with an undefined api.
+        // `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.
         if (this.initialised && this.gridApi) {
-            this.gridApi.setRowData(rowData);
-        }
-    }
-    themeChanged(oldValue, newValue) {
-        if (!newValue) {
-            this.classNames = '';
-            this.destroyFontFace();
-            return;
+            this.gridApi.setGridOption('rowData', rowData);
         }
-        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
@@ -73,6 +123,9 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             this.initGrid();
         }
     }
+    enableColumnSelectionChanged() {
+        this.syncColumnSelectionHostLayout();
+    }
     getfilterModel() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.persistFilterModelKey) {
@@ -93,9 +146,6 @@ export class GridPro 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);
@@ -106,64 +156,24 @@ export class GridPro 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;
-        /**
-         * The default column config to reset to when deleteColumnState is called.
-         */
-        this.defaultColumnConfig = [];
-        this.gridFontFace = defaultAgGridFontFace;
+        /** Wired to `gridOptions.context` for columns picker → grid drag (see bridge module). */
+        this.columnDragBridge = {};
         this.columnComponentName = 'grid-pro-column';
-        this.theme = AgGridTheme.alpine;
         this.themeMode = 'dark';
         /**
          * Configuration for the grid status bar components.
@@ -181,14 +191,27 @@ export class GridPro 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.eventHandlers = [];
+        this.rootEventsListeners = [];
+        this.datasourceEventHandlers = [];
         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;
@@ -196,28 +219,65 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             return map;
         }, {});
         const hideDataSourceError = this.hideDatasourceError.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 the beta grid, so an infinite datasource placed
-     * inside this element can never load data. Report it instead of ignoring the event.
-     * @internal
-     */
-    refuseInfiniteDatasource() {
-        logger.error('grid-pro does not support the Infinite Row Model; use the beta grid (GridProBeta) with grid-pro-infinite-datasource / datasource-type="infinite".');
+        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),
+            ],
+        ];
     }
     /**
      * Adds an event listener to the grid element.
@@ -229,14 +289,12 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      */
     addEventListener(eventType, listener, options) {
         super.addEventListener(eventType, listener, options);
-        if (ComponentUtil.PUBLIC_EVENTS.includes(eventType)) {
-            if (this.gridApi) {
-                this.addGridEventListener(eventType);
-            }
-            else {
-                if (!this.gridEventsQueue.includes(eventType)) {
-                    this.gridEventsQueue.push(eventType);
-                }
+        if (this.gridApi) {
+            this.addGridEventListener(eventType);
+        }
+        else {
+            if (!this.gridEventsQueue.includes(eventType)) {
+                this.gridEventsQueue.push(eventType);
             }
         }
     }
@@ -270,8 +328,12 @@ export class GridPro 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) {
@@ -280,25 +342,44 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             });
         }
         this.rehydrationAttempted = false;
-        this.eventHandlers.forEach(([eventName, handler]) => {
-            this.addEventListener(eventName, handler);
-        });
         if (!this.shouldRunConnect)
             return;
+        this.rootEventsListeners.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.
         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) => {
-                    this.agAttributeChangedCallback(convertToKebabCase(key), undefined, 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);
                 },
                 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;
@@ -306,12 +387,10 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
         super.disconnectedCallback();
         this.rehydrationAttempted = false;
         const shouldRunDisconnect = this.shouldRunDisconnect;
-        this.eventHandlers.forEach(([eventName, handler]) => {
+        this.rootEventsListeners.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();
@@ -321,6 +400,9 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
         }
         this.performDisconnectCleanup();
     }
+    syncColumnSelectionHostLayout() {
+        this.classList.toggle('has-column-selection', this.enableColumnSelection);
+    }
     performDisconnectCleanup() {
         if (this.debounced) {
             clearTimeout(this.debounced);
@@ -329,21 +411,19 @@ export class GridPro 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);
@@ -351,46 +431,42 @@ export class GridPro 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 GridPro.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) {
-            columnDefinitions = this.gridApi.getColumnDefs();
-            this.columnState = this.columnApi.getColumnState();
+            this.columnState = this.gridApi.getColumnState();
         }
-        const gridOptions = Object.assign(Object.assign(Object.assign({}, this.userProvidedGridOptions), (columnDefinitions && { columnDefs: columnDefinitions })), options);
         this.applyingDatasourceGridOptions = true;
         try {
-            this.gridOptions = Object.assign({}, gridOptions);
+            this.gridOptions = Object.assign(Object.assign(Object.assign({}, this.userProvidedGridOptions), options), (keepColDefsOnClearRowData ? { columnDefs: this.gridApi.getColumnDefs() } : {}));
             this.initGrid();
         }
         finally {
@@ -404,7 +480,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
     handleDataLoaded(event) {
         const { data } = event.detail;
         if (this.gridApi) {
-            this.gridApi.setRowData(data);
+            this.gridApi.setGridOption('rowData', data);
         }
     }
     /**
@@ -412,40 +488,25 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      * @internal
      */
     handleDataChanged(event) {
-        var _a, _b, _c;
         const { changes } = event.detail;
-        // 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)
+        // 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)
             return;
-        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 });
-            }
-        }
+        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';
     }
     flashAddedCells(rowNodes) {
         if (this.enableRowFlashing && (rowNodes === null || rowNodes === void 0 ? void 0 : rowNodes.length)) {
@@ -458,8 +519,10 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      */
     handleSchemaUpdated(event) {
         return __awaiter(this, void 0, void 0, function* () {
-            // 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`.
+            // 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.
             if (!this.gridApi) {
                 this.pendingSchemaUpdate = event.detail;
                 return;
@@ -468,44 +531,81 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
         });
     }
     /**
-     * Builds and applies column defs from a schema/metadata payload.
+     * Builds and applies column defs from a schema payload.
      * @internal
      */
     processSchemaUpdate(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ schema, metadata }) {
+        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 legacy `GridProLegacy` behaviour.
             const preSetColumnDefs = this.gridApi.getColumnDefs();
-            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();
+            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';
+                }
+                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;
             }
         });
     }
@@ -514,27 +614,18 @@ export class GridPro 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.setColumnDefs([]);
+            this.gridApi.setGridOption('columnDefs', []);
         }
-        // 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 });
+        // 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', []);
         }
+        this.gridApi.refreshCells({ force: true });
     }
     /**
      * Handles loading started from datasource
@@ -542,7 +633,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      */
     handleLoadingStarted() {
         if (this.gridApi) {
-            this.gridApi.showLoadingOverlay();
+            this.gridApi.setGridOption('loading', true);
         }
     }
     /**
@@ -551,6 +642,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      */
     handleLoadingFinished() {
         if (this.gridApi) {
+            this.gridApi.setGridOption('loading', false);
             this.gridApi.hideOverlay();
         }
     }
@@ -560,6 +652,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      */
     handleNoDataAvailable() {
         if (this.gridApi) {
+            this.gridApi.setGridOption('loading', false);
             this.gridApi.showNoRowsOverlay();
         }
     }
@@ -591,8 +684,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      * Handles datasource errors
      * @internal
      */
-    handleDatasourceError(event) {
-        // Set visual indicator on grid
+    handleDatasourceError() {
         this.setAttribute('ds-disconnected', 'ds-disconnected');
     }
     /**
@@ -619,7 +711,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
     handleSetServerSideDatasource(event) {
         const { datasource } = event.detail;
         if (this.gridApi) {
-            this.gridApi.setServerSideDatasource(datasource);
+            this.gridApi.setGridOption('serverSideDatasource', datasource);
         }
     }
     /**
@@ -672,6 +764,33 @@ export class GridPro 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 GridPro.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,
@@ -686,6 +805,8 @@ export class GridPro 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,
@@ -832,7 +953,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
     saveColumnState() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.rehydrationAttempted && this.statePersistanceEnabled()) {
-                let colState = this.columnApi.getColumnState();
+                let colState = this.gridApi.getColumnState();
                 colState = sanitizeColumnState(colState);
                 colState = this.gridAutosizingEnabled
                     ? this.removeConfigWidthsToAutosize(colState)
@@ -840,7 +961,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
                 const allHeadersHidden = colState.filter((c) => {
                     if (c.hide)
                         return false;
-                    const col = this.columnApi.getColumn(c.colId);
+                    const col = this.gridApi.getColumn(c.colId);
                     return Boolean(col.getColDef().headerName);
                 }).length === 0;
                 if (colState.length === 0 ||
@@ -862,40 +983,11 @@ export class GridPro 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;
@@ -903,7 +995,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             const colState = yield this.getSavedColumnState();
             const sanitizedColState = sanitizeColumnState(colState);
             if (sanitizedColState && sanitizedColState.length > 0) {
-                (_a = this.columnApi) === null || _a === void 0 ? void 0 : _a.applyColumnState({
+                (_a = this.gridApi) === null || _a === void 0 ? void 0 : _a.applyColumnState({
                     state: sanitizedColState,
                     applyOrder: true,
                 });
@@ -941,7 +1033,8 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
      */
     get gridParams() {
         return {
-            globalEventListener: this.boundGlobalEventListener,
+            globalListener: this.boundGlobalEventListener,
+            modules: [gridProColumnDragBridgeModule, ColumnMoveModule, DragAndDropModule],
         };
     }
     /**
@@ -952,7 +1045,14 @@ export class GridPro 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-server-side-datasource') ||
+            this.querySelector('grid-pro-infinite-datasource'));
+    }
+    /**
+     * @public
+     */
+    get isInfiniteRowModel() {
+        return this.gridProDatasource instanceof GridProInfiniteDatasource;
     }
     /**
      * Reports the currently visible columns to the datasource. The datasource decides what to do with
@@ -964,9 +1064,9 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
         const datasource = this.gridProDatasource;
         if (!datasource)
             return;
-        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));
+        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));
         // Skip empty results so we never overwrite a known visible set with nothing (e.g. when the
-        // column API/defs aren't populated yet during early lifecycle).
+        // grid API/defs aren't populated yet during early lifecycle).
         if (!visibleFields.length)
             return;
         datasource.setVisibleColumns(visibleFields);
@@ -983,45 +1083,52 @@ export class GridPro 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 _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;
+        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;
                 this.gridApi = event.api;
-                this.columnApi = event.columnApi;
                 if (this.gridEventsQueue.length) {
                     this.gridEventsQueue.forEach((type) => {
                         this.addGridEventListener(type);
                     });
                 }
-                // Await so columns land before rowData/columnState/ready below - otherwise they'd
-                // race against an empty column model.
+                // 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.
                 if (this.pendingSchemaUpdate) {
                     const pendingSchemaUpdate = this.pendingSchemaUpdate;
                     this.pendingSchemaUpdate = undefined;
-                    yield this.processSchemaUpdate(pendingSchemaUpdate);
+                    try {
+                        yield this.processSchemaUpdate(pendingSchemaUpdate);
+                    }
+                    catch (error) {
+                        logger.error('Grid Pro: failed to apply the pending schema update on grid ready:', error);
+                    }
                 }
                 if (this.rowData) {
-                    this.gridApi.setRowData(this.rowData);
+                    this.gridApi.setGridOption('rowData', this.rowData);
                 }
                 if (onGridReady) {
                     onGridReady(event);
                 }
-                if (this.columnState && ((_a = this.columnState) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                    this.columnApi.applyColumnState({
+                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({
                         state: this.columnState,
                         applyOrder: true,
                     });
@@ -1038,20 +1145,16 @@ export class GridPro 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
-                (_b = this.gridProDatasource) === null || _b === void 0 ? void 0 : _b.$emit(datasourceEventNames.ready);
+                (_c = this.gridProDatasource) === null || _c === void 0 ? void 0 : _c.$emit(datasourceEventNames.ready);
                 this.restoreColumnState();
                 this.restoreCachedFilterConfig();
                 this.debouncedColumnAutosize();
             }), onFirstDataRendered: (event) => {
-                // Handle column sizing
-                this.handleColumnSizing();
-                // Safety net: by now the column API is populated, so (re)seed the datasource's visible
+                // Safety net: by now the grid columns are 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);
                 }
@@ -1076,12 +1179,9 @@ export class GridPro 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;
-            if (hasGetRowId) {
-                derivedOptions.getRowId = getRowId;
-            }
+            derivedOptions.getRowId = getRowId;
             this.setupStatusBar(derivedOptions);
             this.setLocalGridOptions(derivedOptions);
         }
@@ -1091,9 +1191,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
                     return;
                 }
                 derivedOptions.columnDefs = value;
-                if (hasGetRowId) {
-                    derivedOptions.getRowId = getRowId;
-                }
+                derivedOptions.getRowId = getRowId;
                 this.setupStatusBar(derivedOptions);
                 this.setLocalGridOptions(derivedOptions);
                 this.initGrid();
@@ -1101,7 +1199,12 @@ export class GridPro 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.
@@ -1110,25 +1213,17 @@ export class GridPro 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` 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.
+            // `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.
             if (this.disposed || !this.isConnected || !this.gridSlot) {
                 return;
             }
@@ -1140,21 +1235,10 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
                     this.gridSlot.removeChild(this.gridSlot.firstChild);
                 }
             }
-            this.agGrid = new Grid(this.gridSlot, this.agGridOptions, this.gridParams);
+            this.agGrid = createGrid(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
@@ -1182,7 +1266,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
             const templateColumnDefs = Array.from(this.querySelectorAll(this.columnComponentName))
                 .map((templateColumn) => templateColumn.definition)
                 .map((columnDef) => {
-                var _a, _b;
+                var _a, _b, _c, _d, _e, _f;
                 // 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;
@@ -1193,21 +1277,25 @@ export class GridPro 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') {
+                if (columnDef.filter === 'agSetColumnFilter' ||
+                    columnDef.filter === GridProFilterTypes.enumFilter) {
                     const hasExplicitValues = columnDef.filterParams != null && 'values' in columnDef.filterParams;
                     if (!hasExplicitValues) {
-                        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;
+                        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;
                         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,
@@ -1218,9 +1306,6 @@ export class GridPro 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;
@@ -1229,13 +1314,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
                     }
                     if (!columnDef.cellClassRules) {
                         columnDef.cellClassRules = {
-                            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;
-                            },
+                            error: (params) => { var _a; return ((_a = params.data[ERROR_COLUMN_FIELD]) === null || _a === void 0 ? void 0 : _a.column) === params.colDef.field; },
                         };
                     }
                 }
@@ -1268,7 +1347,13 @@ export class GridPro 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) {
-            const isServerSide = this.isServerSide || (gridOptions === null || gridOptions === void 0 ? void 0 : gridOptions.rowModelType) === 'serverSide';
+            // 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';
             if (isServerSide) {
                 if (!this.panelExists(GridProStatusBarTypes.rowCount, statusPanels)) {
                     statusPanels.push({
@@ -1315,7 +1400,9 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
     }
     addDatasourcePanels(statusPanels) {
         if (this.gridProDatasource) {
-            const datasourceStatusPanels = this.gridProDatasource.getDatasourceStatusBarPanels(this.isServerSide, this.statusBarConfig);
+            // 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);
             // Filter out duplicate datasource panels
             const newDatasourcePanels = datasourceStatusPanels.filter((panel) => !this.panelExists(panel.statusPanel, statusPanels));
             statusPanels.push(...newDatasourcePanels);
@@ -1343,94 +1430,6 @@ export class GridPro 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
@@ -1441,6 +1440,7 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
         return lowerCasedPropertyNames.concat(kebabCasePropertyNames);
     }
     agAttributeChangedCallback(attName, oldValue, newValue) {
+        var _a;
         if (oldValue === newValue) {
             return;
         }
@@ -1448,13 +1448,9 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
         if (gridPropertyName) {
             // for properties set before gridOptions is called
             this.agAttributes[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);
+            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);
             }
         }
     }
@@ -1471,24 +1467,7 @@ export class GridPro 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
-], GridPro.prototype, "columnApi", void 0);
 __decorate([
     observable
 ], GridPro.prototype, "gridApi", void 0);
@@ -1507,30 +1486,9 @@ __decorate([
 __decorate([
     attr({ mode: 'boolean', attribute: 'grid-autosizing' })
 ], GridPro.prototype, "gridAutosizingEnabled", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'size-columns-to-content' })
-], GridPro.prototype, "sizeColumnsToContent", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'size-columns-to-fit' })
-], GridPro.prototype, "sizeColumnsToFit", void 0);
-__decorate([
-    attr({ attribute: 'add-index' })
-], GridPro.prototype, "addIndex", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'async-add' })
-], GridPro.prototype, "asyncAdd", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'async-remove' })
-], GridPro.prototype, "asyncRemove", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'async-update' })
-], GridPro.prototype, "asyncUpdate", void 0);
 __decorate([
     attr({ mode: 'boolean', attribute: 'enable-cell-flashing' })
 ], GridPro.prototype, "enableCellFlashing", void 0);
-__decorate([
-    attr({ mode: 'boolean', attribute: 'enabled-row-flashing' })
-], GridPro.prototype, "enabledRowFlashing", void 0);
 __decorate([
     attr({ mode: 'boolean', attribute: 'enable-row-flashing' })
 ], GridPro.prototype, "enableRowFlashing", void 0);
@@ -1540,18 +1498,12 @@ __decorate([
 __decorate([
     attr({ attribute: 'persist-filter-model-key' })
 ], GridPro.prototype, "persistFilterModelKey", void 0);
-__decorate([
-    attr({ attribute: 'default-column-config' })
-], GridPro.prototype, "defaultColumnConfig", void 0);
 __decorate([
     attr({ attribute: 'header-case-type' })
 ], GridPro.prototype, "headerCaseType", void 0);
 __decorate([
     observable
 ], GridPro.prototype, "rowData", void 0);
-__decorate([
-    observable
-], GridPro.prototype, "gridFontFace", void 0);
 __decorate([
     attr
 ], GridPro.prototype, "columnComponentName", void 0);
@@ -1564,9 +1516,6 @@ __decorate([
 __decorate([
     attr
 ], GridPro.prototype, "rowHeight", void 0);
-__decorate([
-    attr
-], GridPro.prototype, "theme", void 0);
 __decorate([
     observable
 ], GridPro.prototype, "classNames", void 0);
@@ -1588,26 +1537,18 @@ __decorate([
 __decorate([
     attr({ mode: 'boolean', attribute: 'with-status-bar' })
 ], GridPro.prototype, "withStatusBar", void 0);
+__decorate([
+    attr({ mode: 'boolean', attribute: 'enable-column-selection' })
+], GridPro.prototype, "enableColumnSelection", void 0);
 __decorate([
     observable
 ], GridPro.prototype, "customErrorHandlerTemplate", void 0);
 __decorate([
     GridOptionsConfig
 ], GridPro.prototype, "gridOptionsConfig", void 0);
-/**
- * GridPro shadow root options.
- * @public
- * @remarks
- * For extensibility, this can be used to set the shadow root mode and delegatesFocus
- */
-export const foundationGridProShadowOptions = undefined;
-/**
- * Grid Pro default configuration.
- * @public
- */
-export const defaultGridProConfig = {
-    shadowOptions: undefined,
-};
+__decorate([
+    observable
+], GridPro.prototype, "provider", void 0);
 /**
  * A function that returns a Foundation Grid Pro registration for configuring the component with a DesignSystem.
  *
@@ -1615,5 +1556,39 @@ export const defaultGridProConfig = {
  * @remarks
  * HTML Element: \<foundation-grid-pro\>
  */
-export const foundationGridPro = GridPro.compose(Object.assign({ baseName: 'grid-pro', styles,
-    template, shadowOptions: foundationGridProShadowOptions }, defaultGridProConfig));
+export const foundationGridPro = GridPro.compose(Object.assign({ baseName: 'grid-pro', template, 
+    // Mirrors what `foundationGridProStyles` gives the legacy grid, minus the AG Grid v29 stock CSS:
+    // the error-handler dialog positions itself against the host, and the column-selection toolbar
+    // needs the host to lay out as a column.
+    styles: css `
+    ${errorHandlerDialogStyles}
+    ${agDragGhostShadowDomStyles}
+    ${gridProColumnSelectionHostStyles}
+    ${rowMatchAlertStyles}
+
+    :host {
+      --datasource-error-background-color: var(--neutral-layer-4);
+      --datasource-error-background-opacity: 0.5;
+      --datasource-error-dialog-max-width: 50%;
+      --datasource-error-dialog-min-width: auto;
+      --ag-status-bar-height: 32.5px;
+
+      position: relative;
+      width: 100%;
+      height: 100%;
+    }
+
+    :host([ds-disconnected]) {
+      display: block;
+    }
+
+    :host([ds-disconnected])::part(grid) {
+      cursor: not-allowed;
+      opacity: 40%;
+      pointer-events: none;
+    }
+
+    .ag-status-bar {
+      height: var(--ag-status-bar-height);
+    }
+  `, shadowOptions: foundationGridProShadowOptions }, defaultGridProConfig));