@toolbox-web/grid 1.26.2 → 1.27.1

package/custom-elements.json

@@ -0,0 +1,1493 @@
+{
+  "schemaVersion": "1.0.0",
+  "readme": "README.md",
+  "modules": [
+    {
+      "kind": "javascript-module",
+      "path": "src/lib/core/grid.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "",
+          "name": "DataGridElement",
+          "members": [
+            {
+              "kind": "field",
+              "name": "tagName",
+              "type": {
+                "text": "string"
+              },
+              "static": true,
+              "readonly": true,
+              "default": "'tbw-grid'"
+            },
+            {
+              "kind": "field",
+              "name": "version",
+              "static": true,
+              "readonly": true,
+              "description": "Version of the grid component, injected at build time from package.json"
+            },
+            {
+              "kind": "method",
+              "name": "registerAdapter",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "adapter",
+                  "type": {
+                    "text": "FrameworkAdapter"
+                  }
+                }
+              ],
+              "description": "Register a framework adapter for handling framework-specific components.\nAdapters are checked in registration order when processing light DOM templates."
+            },
+            {
+              "kind": "method",
+              "name": "getAdapters",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "readonly FrameworkAdapter[]"
+                }
+              },
+              "description": "Get all registered framework adapters.\nUsed internally by light DOM parsing to find adapters that can handle templates."
+            },
+            {
+              "kind": "method",
+              "name": "clearAdapters",
+              "static": true,
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Clear all registered adapters (primarily for testing)."
+            },
+            {
+              "kind": "field",
+              "name": "rows",
+              "type": {
+                "text": "T[]"
+              },
+              "description": "Get or set the row data displayed in the grid.\n\nThe getter returns processed rows (after filtering, sorting, grouping by plugins).\nThe setter accepts new source data and triggers a re-render."
+            },
+            {
+              "kind": "field",
+              "name": "sourceRows",
+              "type": {
+                "text": "T[]"
+              },
+              "description": "Get the original unfiltered/unprocessed source rows.\n\nUse this when you need access to all source data regardless of active\nfilters, sorting, or grouping applied by plugins. The `rows` property\nreturns processed data, while `sourceRows` returns the original input."
+            },
+            {
+              "kind": "field",
+              "name": "columns",
+              "type": {
+                "text": "ColumnConfig<T>[]"
+              },
+              "description": "Get or set the column configurations.\n\nThe getter returns processed columns (after plugin transformations).\nThe setter accepts an array of column configs or a column config map."
+            },
+            {
+              "kind": "field",
+              "name": "gridConfig",
+              "type": {
+                "text": "GridConfig<T>"
+              },
+              "description": "Get or set the full grid configuration object.\n\nThe getter returns the effective (merged) configuration.\nThe setter accepts a new configuration and triggers a full re-render."
+            },
+            {
+              "kind": "field",
+              "name": "fitMode",
+              "type": {
+                "text": "FitMode"
+              },
+              "description": "Get or set the column sizing mode.\n\n- `'stretch'` (default): Columns stretch to fill available width\n- `'fixed'`: Columns use explicit widths; horizontal scroll if needed\n- `'auto'`: Columns auto-size to content on initial render"
+            },
+            {
+              "kind": "field",
+              "name": "loading",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Whether the grid is currently in a loading state.\nWhen true, displays a loading overlay with spinner (or custom loadingRenderer)."
+            },
+            {
+              "kind": "method",
+              "name": "setRowLoading",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The row's unique identifier (from getRowId)"
+                },
+                {
+                  "name": "loading",
+                  "type": {
+                    "text": "boolean"
+                  },
+                  "description": "Whether the row is loading"
+                }
+              ],
+              "description": "Set loading state for a specific row.\nShows a small spinner indicator on the row."
+            },
+            {
+              "kind": "method",
+              "name": "setCellLoading",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The row's unique identifier"
+                },
+                {
+                  "name": "field",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The column field"
+                },
+                {
+                  "name": "loading",
+                  "type": {
+                    "text": "boolean"
+                  },
+                  "description": "Whether the cell is loading"
+                }
+              ],
+              "description": "Set loading state for a specific cell.\nShows a small spinner indicator on the cell."
+            },
+            {
+              "kind": "method",
+              "name": "isRowLoading",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The row's unique identifier"
+                }
+              ],
+              "description": "Check if a row is currently in loading state."
+            },
+            {
+              "kind": "method",
+              "name": "isCellLoading",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The row's unique identifier"
+                },
+                {
+                  "name": "field",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The column field"
+                }
+              ],
+              "description": "Check if a cell is currently in loading state."
+            },
+            {
+              "kind": "method",
+              "name": "clearAllLoading",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Clear all row and cell loading states."
+            },
+            {
+              "kind": "method",
+              "name": "getPlugin",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "PluginClass",
+                  "type": {
+                    "text": "new (...args: any[]) => P"
+                  },
+                  "description": "The plugin class (constructor) to look up."
+                }
+              ],
+              "description": "Get a plugin instance by its class constructor.\n\n**Prefer getPluginByName** for most use cases — it avoids importing the plugin class\nand returns the actual instance registered in the grid."
+            },
+            {
+              "kind": "method",
+              "name": "getPluginByName",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "K"
+                  },
+                  "description": "The plugin name (matches {@link BaseGridPlugin.name}).\n   * "
+                }
+              ],
+              "description": "Get a plugin instance by its string name.\nUseful for loose coupling when you don't want to import the plugin class\n(e.g., in framework adapters or dynamic scenarios)."
+            },
+            {
+              "kind": "method",
+              "name": "addEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "K"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "(this: DataGridElement<T>, ev: CustomEvent<DataGridEventMap<T>[K]>) => void"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | AddEventListenerOptions"
+                  }
+                }
+              ],
+              "description": "Add a typed event listener for grid events.\n\nThis override provides type-safe event handling for DataGrid-specific events.\nThe event detail is automatically typed based on the event name.\n\n**Prefer on| grid.on()** for most use cases — it auto-unwraps the\ndetail payload and returns an unsubscribe function for easy cleanup.\n\nUse `addEventListener` when you need standard DOM options like `once`,\n`capture`, `passive`, or `signal` (AbortController)."
+            },
+            {
+              "kind": "method",
+              "name": "addEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListenerOrEventListenerObject"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | AddEventListenerOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "addEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListenerOrEventListenerObject | ((ev: CustomEvent) => void)"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | AddEventListenerOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "removeEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "K"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "(this: DataGridElement<T>, ev: CustomEvent<DataGridEventMap<T>[K]>) => void"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | EventListenerOptions"
+                  }
+                }
+              ],
+              "description": "Remove a typed event listener for grid events."
+            },
+            {
+              "kind": "method",
+              "name": "removeEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListenerOrEventListenerObject"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | EventListenerOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "removeEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "EventListenerOrEventListenerObject | ((ev: CustomEvent) => void)"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | EventListenerOptions"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "on",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "K"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "(detail: DataGridEventMap<T>[K], event: CustomEvent<DataGridEventMap<T>[K]>) => void"
+                  }
+                }
+              ],
+              "description": "Subscribe to a typed grid event. **Recommended** over `addEventListener`.\n\nReturns an unsubscribe function — call it to remove the listener.\nThe listener receives the event **detail** as its first argument\n(no need to dig into `e.detail`), and the raw `CustomEvent` as\nthe second argument when you need `preventDefault()` or `stopPropagation()`."
+            },
+            {
+              "kind": "method",
+              "name": "on",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "(detail: unknown, event: CustomEvent) => void"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "on",
+              "return": {
+                "type": {
+                  "text": "() => void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "(detail: unknown, event: CustomEvent) => void"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "ready",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Wait for the grid to be ready.\nResolves once the component has finished initial setup, including\ncolumn inference, plugin initialization, and first render."
+            },
+            {
+              "kind": "method",
+              "name": "forceLayout",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Force a full layout/render cycle.\nUse this after programmatic changes that require re-measurement,\nsuch as container resize or dynamic style changes."
+            },
+            {
+              "kind": "method",
+              "name": "getConfig",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Get a frozen snapshot of the current effective configuration.\nThe returned object is read-only and reflects all merged config sources."
+            },
+            {
+              "kind": "method",
+              "name": "getRowId",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "row",
+                  "type": {
+                    "text": "T"
+                  },
+                  "description": "The row object"
+                }
+              ],
+              "description": "Get the unique ID for a row.\nUses the configured `getRowId` function or falls back to `row.id` / `row._id`."
+            },
+            {
+              "kind": "method",
+              "name": "getRow",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "id",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "Row identifier (from getRowId)"
+                }
+              ],
+              "description": "Get a row by its ID.\nO(1) lookup via internal Map."
+            },
+            {
+              "kind": "method",
+              "name": "updateRow",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "id",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "Row identifier (from getRowId)"
+                },
+                {
+                  "name": "changes",
+                  "type": {
+                    "text": "Partial<T>"
+                  },
+                  "description": "Partial row data to merge"
+                },
+                {
+                  "name": "source",
+                  "default": "'api'",
+                  "type": {
+                    "text": "UpdateSource"
+                  },
+                  "description": "Origin of update (default: 'api')"
+                }
+              ],
+              "description": "Update a row by ID.\nMutates the row in-place and emits `cell-change` for each changed field."
+            },
+            {
+              "kind": "method",
+              "name": "updateRows",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "updates",
+                  "type": {
+                    "text": "Array<{ id: string; changes: Partial<T> }>"
+                  },
+                  "description": "Array of { id, changes } objects"
+                },
+                {
+                  "name": "source",
+                  "default": "'api'",
+                  "type": {
+                    "text": "UpdateSource"
+                  },
+                  "description": "Origin of updates (default: 'api')"
+                }
+              ],
+              "description": "Batch update multiple rows.\nMore efficient than multiple `updateRow()` calls - single render cycle."
+            },
+            {
+              "kind": "method",
+              "name": "animateRow",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowIndex",
+                  "type": {
+                    "text": "number"
+                  },
+                  "description": "Index of the row in the current row set"
+                },
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "RowAnimationType"
+                  },
+                  "description": "Type of animation to apply"
+                }
+              ],
+              "description": "Animate a row at the specified index.\nApplies a visual animation to highlight changes, insertions, or removals.\nReturns a `Promise` that resolves when the animation completes.\n\n**Animation types:**\n- `'change'`: Flash highlight (for data changes, e.g., after cell edit)\n- `'insert'`: Slide-in animation (for newly added rows)\n- `'remove'`: Fade-out animation (for rows being removed)\n\nThe animation is purely visual - it does not affect the data.\nFor remove animations, the row remains in the DOM until animation completes."
+            },
+            {
+              "kind": "method",
+              "name": "animateRows",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowIndices",
+                  "type": {
+                    "text": "number[]"
+                  },
+                  "description": "Indices of the rows to animate"
+                },
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "RowAnimationType"
+                  },
+                  "description": "Type of animation to apply to all rows"
+                }
+              ],
+              "description": "Animate multiple rows at once.\nMore efficient than calling `animateRow()` multiple times.\nReturns a `Promise` that resolves when all animations complete."
+            },
+            {
+              "kind": "method",
+              "name": "animateRowById",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The row's unique identifier (from getRowId)"
+                },
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "RowAnimationType"
+                  },
+                  "description": "Type of animation to apply"
+                }
+              ],
+              "description": "Animate a row by its ID.\nUses the configured `getRowId` function to find the row.\nReturns a `Promise` that resolves when the animation completes."
+            },
+            {
+              "kind": "method",
+              "name": "insertRow",
+              "return": {
+                "type": {
+                  "text": "Promise<void>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "index",
+                  "type": {
+                    "text": "number"
+                  },
+                  "description": "Visible row index at which to insert (0-based)"
+                },
+                {
+                  "name": "row",
+                  "type": {
+                    "text": "T"
+                  },
+                  "description": "The row data object to insert"
+                },
+                {
+                  "name": "animate",
+                  "default": "true",
+                  "description": "Whether to apply an 'insert' animation (default: `true`)"
+                }
+              ],
+              "description": "Insert a row at a specific position in the current view.\n\nThe row is spliced into the visible (processed) row array at `index` and\nappended to the source data so that future pipeline runs (sort, filter,\ngroup) include it. No plugin processing is triggered — the row stays\nexactly where you place it until the next full pipeline run.\n\nBy default, an `'insert'` animation is applied. Pass `animate: false` to\nskip the animation. The returned `Promise` resolves when the animation\ncompletes (or immediately when `animate` is `false`)."
+            },
+            {
+              "kind": "method",
+              "name": "removeRow",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "index",
+                  "type": {
+                    "text": "number"
+                  },
+                  "description": "Visible row index to remove (0-based)"
+                },
+                {
+                  "name": "animate",
+                  "default": "true",
+                  "description": "Whether to apply a 'remove' animation first (default: `true`)"
+                }
+              ],
+              "description": "Remove a row at a specific position in the current view.\n\nThe row is removed from both the visible (processed) row array and the\nsource data. No plugin processing is triggered — remaining rows keep their\ncurrent positions until the next full pipeline run.\n\nBy default, a `'remove'` animation plays before the row is removed.\nPass `animate: false` to remove immediately. When animated, `await` the\nresult to ensure the row has been fully removed from data."
+            },
+            {
+              "kind": "method",
+              "name": "applyTransaction",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "transaction",
+                  "type": {
+                    "text": "RowTransaction<T>"
+                  },
+                  "description": "The mutations to apply"
+                },
+                {
+                  "name": "animate",
+                  "default": "true",
+                  "description": "Whether to animate the changes (default: `true`)"
+                }
+              ],
+              "description": "Apply a batch of row mutations (add, update, remove) in a single render cycle.\n\nThis is the most efficient way to apply multiple row changes at once — ideal\nfor streaming data from WebSocket, SSE, or any real-time source.\n\nOperations are applied in order: removes → updates → adds. This ensures\nupdates don't target rows about to be removed, and adds don't collide\nwith existing rows."
+            },
+            {
+              "kind": "method",
+              "name": "applyTransactionAsync",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "transaction",
+                  "type": {
+                    "text": "RowTransaction<T>"
+                  },
+                  "description": "The mutations to apply"
+                }
+              ],
+              "description": "Apply a transaction asynchronously, batching rapid calls into a single render.\n\nIdeal for high-frequency streaming where many small updates arrive faster\nthan the browser can render. All transactions queued within the same\nanimation frame are merged and applied together.\n\nAnimations are disabled for batched transactions to avoid visual overload."
+            },
+            {
+              "kind": "method",
+              "name": "suspendProcessing",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Suspend row processing for the next rows update.",
+              "deprecated": []
+            },
+            {
+              "kind": "method",
+              "name": "focusCell",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowIndex",
+                  "type": {
+                    "text": "number"
+                  },
+                  "description": "The row index to focus (0-based, in the current processed row array)"
+                },
+                {
+                  "name": "column",
+                  "type": {
+                    "text": "number | string"
+                  },
+                  "description": "Column index (0-based into visible columns) or field name string"
+                }
+              ],
+              "description": "Move focus to a specific cell.\n\nAccepts a column index (into the visible columns array) or a field name.\nThe grid scrolls the cell into view and applies focus styling."
+            },
+            {
+              "kind": "field",
+              "name": "focusedCell",
+              "type": {
+                "text": "{ rowIndex: number; colIndex: number; field: string } | null"
+              },
+              "description": "The currently focused cell position, or `null` if no rows are loaded.\n\nReturns a snapshot object with the row index, visible column index, and\nthe field name of the focused column.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "scrollToRow",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowIndex",
+                  "type": {
+                    "text": "number"
+                  },
+                  "description": "Row index (0-based, in the current processed row array)"
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "ScrollToRowOptions"
+                  },
+                  "description": "Alignment and scroll behavior"
+                }
+              ],
+              "description": "Scroll the viewport so a row is visible.\n\nUses the grid's internal virtualization state (row height, position cache)\nto calculate the correct scroll offset, including support for variable\nrow heights and grouped rows."
+            },
+            {
+              "kind": "method",
+              "name": "scrollToRowById",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The row's unique identifier"
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "ScrollToRowOptions"
+                  },
+                  "description": "Alignment and scroll behavior"
+                }
+              ],
+              "description": "Scroll the viewport so a row is visible, identified by its unique ID.\n\nUses GridConfig.getRowId| getRowId (or the fallback `row.id` / `row._id`)\nto find the row in the current (possibly sorted/filtered) data, then delegates\nto scrollToRow."
+            },
+            {
+              "kind": "method",
+              "name": "setColumnVisible",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "field",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The field name of the column to modify"
+                },
+                {
+                  "name": "visible",
+                  "type": {
+                    "text": "boolean"
+                  },
+                  "description": "Whether the column should be visible"
+                }
+              ],
+              "description": "Show or hide a column by field name."
+            },
+            {
+              "kind": "method",
+              "name": "toggleColumnVisibility",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "field",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The field name of the column to toggle"
+                }
+              ],
+              "description": "Toggle a column's visibility."
+            },
+            {
+              "kind": "method",
+              "name": "isColumnVisible",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "parameters": [
+                {
+                  "name": "field",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The field name to check"
+                }
+              ],
+              "description": "Check if a column is currently visible."
+            },
+            {
+              "kind": "method",
+              "name": "showAllColumns",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Show all columns, resetting any hidden columns to visible."
+            },
+            {
+              "kind": "method",
+              "name": "getAllColumns",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Get metadata for all columns including visibility state.\nUseful for building a column picker UI."
+            },
+            {
+              "kind": "method",
+              "name": "setColumnOrder",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "order",
+                  "type": {
+                    "text": "string[]"
+                  },
+                  "description": "Array of field names in desired order"
+                }
+              ],
+              "description": "Set the display order of columns."
+            },
+            {
+              "kind": "method",
+              "name": "getColumnOrder",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Get the current column display order."
+            },
+            {
+              "kind": "method",
+              "name": "getColumnState",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Get the current column state for persistence.\nReturns a serializable object including column order, widths, visibility,\nsort state, and any plugin-specific state.\n\nUse this to save user preferences to localStorage or a database."
+            },
+            {
+              "kind": "field",
+              "name": "columnState",
+              "description": "Get the current column state.\nAlias for `getColumnState()` for property-style access.",
+              "type": {
+                "text": "GridColumnState | undefined"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "resetColumnState",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Reset column state to initial configuration.\nClears all user modifications including order, widths, visibility, and sort."
+            },
+            {
+              "kind": "field",
+              "name": "isToolPanelOpen",
+              "type": {
+                "text": "boolean"
+              },
+              "description": "Check if the tool panel sidebar is currently open.\n\nThe tool panel is an accordion-based sidebar that contains sections\nregistered by plugins or via `registerToolPanel()`.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "defaultRowHeight",
+              "type": {
+                "text": "number"
+              },
+              "description": "The default row height in pixels.\n\nFor fixed heights, this is the configured or CSS-measured row height.\nFor variable heights, this is the average/estimated row height.\nPlugins should use this instead of hardcoding row heights.",
+              "readonly": true
+            },
+            {
+              "kind": "field",
+              "name": "expandedToolPanelSections",
+              "type": {
+                "text": "string[]"
+              },
+              "description": "Get the IDs of currently expanded accordion sections in the tool panel.\n\nMultiple sections can be expanded simultaneously in the accordion view.",
+              "readonly": true
+            },
+            {
+              "kind": "method",
+              "name": "openToolPanel",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Open the tool panel sidebar.\n\nThe tool panel displays an accordion view with all registered panel sections.\nEach section can be expanded/collapsed independently."
+            },
+            {
+              "kind": "method",
+              "name": "closeToolPanel",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Close the tool panel sidebar."
+            },
+            {
+              "kind": "method",
+              "name": "toggleToolPanel",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Toggle the tool panel sidebar open or closed."
+            },
+            {
+              "kind": "method",
+              "name": "toggleToolPanelSection",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "sectionId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The ID of the section to toggle (matches `ToolPanelDefinition.id`)"
+                }
+              ],
+              "description": "Toggle an accordion section expanded or collapsed within the tool panel."
+            },
+            {
+              "kind": "method",
+              "name": "getToolPanels",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Get all registered tool panel definitions.\n\nReturns both plugin-registered panels and panels registered via `registerToolPanel()`."
+            },
+            {
+              "kind": "method",
+              "name": "registerToolPanel",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "panel",
+                  "type": {
+                    "text": "ToolPanelDefinition"
+                  },
+                  "description": "The tool panel definition"
+                }
+              ],
+              "description": "Register a custom tool panel section.\n\nUse this API to add custom UI sections to the tool panel sidebar\nwithout creating a full plugin. The panel will appear as an accordion\nsection in the tool panel."
+            },
+            {
+              "kind": "method",
+              "name": "unregisterToolPanel",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "panelId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The ID of the panel to remove"
+                }
+              ],
+              "description": "Unregister a custom tool panel section."
+            },
+            {
+              "kind": "method",
+              "name": "getHeaderContents",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Get all registered header content definitions."
+            },
+            {
+              "kind": "method",
+              "name": "registerHeaderContent",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "content",
+                  "type": {
+                    "text": "HeaderContentDefinition"
+                  },
+                  "description": "The header content definition"
+                }
+              ],
+              "description": "Register custom header content.\n\nHeader content appears in the grid's header bar area, which is displayed\nabove the column headers. Use this for search boxes, filters, or other\ncontrols that should be prominently visible."
+            },
+            {
+              "kind": "method",
+              "name": "unregisterHeaderContent",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "contentId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The ID of the content to remove"
+                }
+              ],
+              "description": "Unregister custom header content."
+            },
+            {
+              "kind": "method",
+              "name": "getToolbarContents",
+              "return": {
+                "type": {
+                  "text": ""
+                }
+              },
+              "description": "Get all registered toolbar content definitions."
+            },
+            {
+              "kind": "method",
+              "name": "registerToolbarContent",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "content",
+                  "type": {
+                    "text": "ToolbarContentDefinition"
+                  },
+                  "description": "The toolbar content definition"
+                }
+              ],
+              "description": "Register custom toolbar content.\n\nToolbar content appears in the grid's toolbar area. Use this for action\nbuttons, dropdowns, or other controls that should be easily accessible.\nContent is rendered in order of the `order` property (lower = first)."
+            },
+            {
+              "kind": "method",
+              "name": "unregisterToolbarContent",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "contentId",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The ID of the content to remove"
+                }
+              ],
+              "description": "Unregister custom toolbar content."
+            },
+            {
+              "kind": "method",
+              "name": "registerStyles",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "id",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "Unique identifier for the style block (for removal/updates)"
+                },
+                {
+                  "name": "css",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "CSS string to inject"
+                }
+              ],
+              "description": "Register custom CSS styles to be injected into the grid's shadow DOM.\nUse this to style custom cell renderers, editors, or detail panels.\n\nUses adoptedStyleSheets for efficiency - styles survive shadow DOM rebuilds."
+            },
+            {
+              "kind": "method",
+              "name": "unregisterStyles",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "id",
+                  "type": {
+                    "text": "string"
+                  },
+                  "description": "The ID used when registering the styles"
+                }
+              ],
+              "description": "Remove previously registered custom styles."
+            },
+            {
+              "kind": "method",
+              "name": "getRegisteredStyles",
+              "return": {
+                "type": {
+                  "text": "string[]"
+                }
+              },
+              "description": "Get list of registered custom style IDs."
+            },
+            {
+              "kind": "method",
+              "name": "registerExternalFocusContainer",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "el",
+                  "type": {
+                    "text": "Element"
+                  },
+                  "description": "The external element to register"
+                }
+              ],
+              "description": "Register an external DOM element as a logical focus container of this grid.\n\nFocus moving into a registered container is treated as if it stayed inside\nthe grid: `data-has-focus` is preserved, click-outside commit is suppressed,\nand the editing focus trap (when enabled) won't reclaim focus.\n\nTypical use case: overlay panels (datepickers, dropdowns, autocompletes)\nthat render at `<body>` level to escape grid overflow clipping."
+            },
+            {
+              "kind": "method",
+              "name": "unregisterExternalFocusContainer",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "el",
+                  "type": {
+                    "text": "Element"
+                  },
+                  "description": "The element to unregister"
+                }
+              ],
+              "description": "Unregister a previously registered external focus container."
+            },
+            {
+              "kind": "method",
+              "name": "containsFocus",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "node",
+                  "optional": true,
+                  "type": {
+                    "text": "Node | null"
+                  },
+                  "description": "Optional node to test. Defaults to `document.activeElement`."
+                }
+              ],
+              "description": "Check whether focus is logically inside this grid.\n\nReturns `true` when `document.activeElement` (or the given node) is\ninside the grid's own DOM **or** inside any element registered via\nregisterExternalFocusContainer."
+            },
+            {
+              "kind": "method",
+              "name": "refreshColumns",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Re-parse light DOM column elements and refresh the grid.\nCall this after framework adapters have registered their templates.\nUses the render scheduler to batch with other pending updates."
+            },
+            {
+              "kind": "method",
+              "name": "invalidateRowHeight",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "rowIndex",
+                  "type": {
+                    "text": "number"
+                  },
+                  "description": "Index of the row whose height changed"
+                },
+                {
+                  "name": "newHeight",
+                  "optional": true,
+                  "type": {
+                    "text": "number"
+                  },
+                  "description": "Optional new height. If not provided, queries plugins for height."
+                }
+              ],
+              "description": "Invalidate a row's height in the position cache.\nCall this when a plugin changes a row's height (e.g., expanding/collapsing a detail panel)."
+            }
+          ],
+          "events": [
+            {
+              "name": "eventName",
+              "type": {
+                "text": "CustomEvent"
+              }
+            }
+          ],
+          "attributes": [
+            {
+              "name": "rows"
+            },
+            {
+              "name": "columns"
+            },
+            {
+              "name": "grid-config"
+            },
+            {
+              "name": "fit-mode"
+            },
+            {
+              "name": "loading"
+            }
+          ],
+          "superclass": {
+            "name": "HTMLElement"
+          },
+          "tagName": "tbw-grid",
+          "customElement": true
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "DataGridElement",
+          "declaration": {
+            "name": "DataGridElement",
+            "module": "src/lib/core/grid.ts"
+          }
+        },
+        {
+          "kind": "custom-element-definition",
+          "name": "tbw-grid",
+          "declaration": {
+            "name": "DataGridElement",
+            "module": "src/lib/core/grid.ts"
+          }
+        }
+      ]
+    }
+  ]
+}