@timlassiter11/yatl 1.2.5 → 1.3.0

package/dist/index.d.mts

@@ -1,6 +1,260 @@
 import * as lit from 'lit';
-import { TemplateResult, ReactiveController, ReactiveControllerHost, LitElement, nothing } from 'lit';
+import { ReactiveController, ReactiveControllerHost, TemplateResult, LitElement, nothing, PropertyValues } from 'lit';
 import { DirectiveResult } from 'lit/directive.js';
+import * as lit_html from 'lit-html';
+
+declare class TypedEventTarget<TEventMap extends Record<string, Event>> extends EventTarget {
+    addEventListener<K extends keyof TEventMap>(type: K, listener: (this: TEventMap, ev: TEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof TEventMap>(type: K, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+    dispatchEvent<K extends keyof TEventMap>(event: TEventMap[K]): boolean;
+}
+
+declare class YatlTableController<T extends object = UnspecifiedRecord> extends TypedEventTarget<ControllerEventMap> implements ReactiveController, YatlTableControllerApi<T> {
+    private hosts;
+    private _tokenizedSearch;
+    private _scoredSearch;
+    private _columns;
+    private _columnDefinitionMap;
+    private _columnStateMap;
+    private _rowSelectionMethod;
+    private _selectedRowIds;
+    private _storageOptions;
+    private _rowIdCallback;
+    private _data;
+    private _filteredData;
+    private _dataUpdateTimestamp;
+    private _searchQuery;
+    private _searchTokenizer;
+    private _filters;
+    private hasRestoredState;
+    private saveTimer;
+    private filterDirty;
+    private sortDirty;
+    private rowMetadata;
+    private idToRowMap;
+    private queryTokens;
+    get columns(): ColumnOptions<T>[];
+    set columns(columns: ColumnOptions<T>[]);
+    get displayColumns(): DisplayColumnOptions<T>[];
+    get columnStates(): ColumnState<T>[];
+    set columnStates(states: ColumnState<T>[]);
+    get data(): T[];
+    set data(data: T[]);
+    get filteredData(): T[];
+    get dataUpdateTimestamp(): Date | null;
+    get filters(): FilterCallback<T> | Partial<{ [K in NestedKeyOf<T>]: unknown; }> | null;
+    set filters(filters: FilterCallback<T> | Partial<{ [K in NestedKeyOf<T>]: unknown; }> | null);
+    get searchQuery(): string;
+    set searchQuery(query: string);
+    get tokenizedSearch(): boolean;
+    set tokenizedSearch(enable: boolean);
+    get scoredSearch(): boolean;
+    set scoredSearch(enable: boolean);
+    get searchTokenizer(): TokenizerCallback;
+    set searchTokenizer(tokenizer: TokenizerCallback);
+    get rowSelectionMethod(): RowSelectionMethod | null;
+    set rowSelectionMethod(selection: RowSelectionMethod | null);
+    get selectedRowIds(): RowId[];
+    set selectedRowIds(rows: RowId[]);
+    get rowIdCallback(): RowIdCallback<T>;
+    set rowIdCallback(callback: RowIdCallback<T>);
+    get storageOptions(): {
+        key: string;
+        storage?: StorageInterface;
+        saveSearchQuery?: boolean;
+        saveColumnSortOrders?: boolean;
+        saveColumnVisibility?: boolean;
+        saveColumnWidths?: boolean;
+        saveColumnOrder?: boolean;
+        saveSelectedRows?: boolean;
+    } | null;
+    set storageOptions(options: {
+        key: string;
+        storage?: StorageInterface;
+        saveSearchQuery?: boolean;
+        saveColumnSortOrders?: boolean;
+        saveColumnVisibility?: boolean;
+        saveColumnWidths?: boolean;
+        saveColumnOrder?: boolean;
+        saveSelectedRows?: boolean;
+    } | null);
+    constructor(host?: ReactiveControllerHost, options?: TableControllerOptions<T>);
+    attach(host: ReactiveControllerHost): void;
+    detach(host: ReactiveControllerHost): void;
+    getColumn(field: NestedKeyOf<T>): ColumnOptions<T> | undefined;
+    getDisplayColumn(field: NestedKeyOf<T>): DisplayColumnOptions<T> | undefined;
+    /**
+     * Gets a copy of the current state of the table.
+     */
+    getTableState(): TableState<T>;
+    /**
+     * Restores the table to the provided state.
+     * @param state - The state to restore the table to.
+     */
+    updateTableState(state: RestorableTableState<T>): void;
+    getColumnState(field: NestedKeyOf<T>): ColumnState<T>;
+    updateColumnState(field: NestedKeyOf<T>, state: RestorableColumnState<T>): void;
+    search(query: string): void;
+    getColumnFilterValues(field: NestedKeyOf<T>, includeNull?: boolean): Map<unknown, number>;
+    /**
+     * Sorts the table by a specified column and order.
+     * If `order` is `null`, the sort on this column is removed.
+     * @param field - The field name of the column to sort by.
+     * @param order - The sort order: 'asc', 'desc', or `null` to remove sorting for this column.
+     * @param clear - Clear all other sorting
+     */
+    sort(field: NestedKeyOf<T>, order: SortOrder | null, clear?: boolean): void;
+    /**
+     * Toggles the visibility of hte specified column
+     * @param field - The field name of the column to toggle.
+     * @param visible - Optionally force the visibility state.
+     */
+    toggleColumnVisibility(field: NestedKeyOf<T>, visible?: boolean): void;
+    /**
+     * Shows the specified column
+     * @param field - The field name of the column to show.
+     */
+    showColumn(field: NestedKeyOf<T>): void;
+    /**
+     * Hides the specified column
+     * @param field - The field name of the column to hide.
+     */
+    hideColumn(field: NestedKeyOf<T>): void;
+    /**
+     * Moves a column to a new position
+     * @param field - The column to move
+     * @param newPosition The index or field of the column to move it to.
+     * @returns
+     */
+    moveColumn(field: NestedKeyOf<T>, newPosition: number | NestedKeyOf<T>): void;
+    resizeColumn(field: NestedKeyOf<T>, width: number | null): void;
+    isRowSelected(row: T): boolean;
+    /**
+     * Toggles the selection state of a specific row.
+     */
+    toggleRowSelection(row: T, state?: boolean): void;
+    /**
+     * Selects a specific row.
+     */
+    selectRow(row: T): void;
+    /**
+     * Deselects a specific row.
+     */
+    deselectRow(row: T): void;
+    /**
+     * Selects all currently visible rows (for "Select All" checkbox).
+     */
+    selectAll(): void;
+    /**
+     * Clears all selection.
+     */
+    deselectAll(): void;
+    /**
+     * Export the current visible table data to a CSV file.
+     * @param options - Options for configuring what should be exported.
+     */
+    export(options?: ExportOptions): Blob;
+    /**
+     * Gets the row associated with the provided ID.
+     * @param id - The ID of the row to get
+     * @returns
+     */
+    getRow(id: RowId): T | undefined;
+    /**
+     * Finds the first row where {@link field} matches {@link value}
+     * @param field - The field name within the row data to search.
+     * @param value - The value to match against the field's content.
+     * @returns The found row, or undefined if no match is found.
+     */
+    findRow(field: NestedKeyOf<T>, value: unknown): T | undefined;
+    /**
+     * Finds the original index of the first row where the specified field matches the given value.
+     * This searches through the original, unfiltered dataset.
+     * @param field - The field name within the row data to search.
+     * @param value - The value to match against the field's content.
+     * @returns The original index of the found row, or -1 if no match is found.
+     * @example
+     * ```ts
+     * const index = dataTable.indexOf('id', 12345);
+     * if (index >= 0) {
+     *  dataTable.updateRow({description: "Updated description"}, index);
+     * }
+     * ```
+     */
+    findRowIndex(field: NestedKeyOf<T>, value: unknown): number;
+    updateRow(rowId: RowId, data: Partial<T>): void;
+    /**
+     * Updates the data of a row at a specific original index.
+     * @param index - The original index of the row to update.
+     * @param data - An object containing the new data to assign to the row. Existing fields will be updated, and new fields will be added.
+     *
+     * @example
+     * ```ts
+     * const index = dataTable.indexOf('id', 12345);
+     * if (index >= 0) {
+     *  dataTable.updateRow(index, {description: "Updated description"});
+     * }
+     * ```
+     */
+    updateRowAtIndex(index: number, data: Partial<T>): void;
+    /**
+     * Deletes the row with the matching ID.
+     * @param rowIds - The IDs rows to delete
+     */
+    deleteRow(...rowIds: RowId[]): void;
+    /**
+     * Deletes a row at a specific original index from the table.
+     * @param indexes - The original indexes of rows to delete.
+     */
+    deleteRowAtIndex(...indexes: number[]): void;
+    getRowId(row: T): RowId;
+    getRowIndex(row: T): number;
+    getRowHighlightIndicies(row: T): Record<string, [number, number][]> | undefined;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    hostUpdate(): void;
+    hostUpdated(): void;
+    requestUpdate(...props: (keyof YatlTableController)[]): void;
+    /**
+     * Calculates a relevance score for a given query against a target string.
+     *
+     * This function implements a tiered matching strategy:
+     * 1.  **Exact Match**: The query exactly matches the target. This yields the highest score.
+     * 2.  **Prefix Match**: The target starts with the query. This is the next most relevant.
+     * 3.  **Substring Match**: The target contains the query somewhere. This is the least relevant.
+     *
+     * The final score is weighted and adjusted by the length difference between the query and the target
+     * to ensure that more specific matches (e.g., "apple" vs "application" for the query "apple") rank higher.
+     *
+     * @param query The search term (e.g., "app").
+     * @param target The string to be searched (e.g., "Apple" or "Application").
+     * @returns A numerical score representing the relevance of the match. Higher is better. Returns 0 if no match is found.
+     */
+    private calculateSearchScore;
+    private searchField;
+    private filterField;
+    private filterRow;
+    private filterRows;
+    private compareRows;
+    private sortRows;
+    private createMetadata;
+    private updateRowData;
+    private updateInternalQuery;
+    private scheduleSave;
+    private saveStateToStorage;
+    private loadStateFromStorage;
+}
+type ControllerEventMap = {
+    [YatlColumnReorderEvent.EVENT_NAME]: YatlColumnReorderEvent;
+    [YatlColumnResizeEvent.EVENT_NAME]: YatlColumnResizeEvent;
+    [YatlColumnSortEvent.EVENT_NAME]: YatlColumnSortEvent;
+    [YatlColumnToggleEvent.EVENT_NAME]: YatlColumnToggleEvent;
+    [YatlRowSelectEvent.EVENT_NAME]: YatlRowSelectEvent;
+    [YatlTableSearchEvent.EVENT_NAME]: YatlTableSearchEvent;
+    [YatlTableStateChangeEvent.EVENT_NAME]: YatlTableStateChangeEvent;
+    [YatlTableViewChangeEvent.EVENT_NAME]: YatlTableViewChangeEvent;
+};
 
 type NestedKeyOf<ObjectType> = ObjectType extends object ? {
     [Key in keyof ObjectType & (string | number)]: NonNullable<ObjectType[Key]> extends unknown[] ? `${Key}` : NonNullable<ObjectType[Key]> extends object ? // Recurse with the non-nullable type
@@ -22,12 +276,13 @@ type Compareable = string | number | boolean | Date;
  * Safe types for render callbacks
  */
 type Renderable = string | number | boolean | null | undefined | TemplateResult | DirectiveResult;
+type MaybePromise<T> = Promise<T> | T;
 
 /**
  * A filter object containing keys for the fields to be filtered,
  * and the values used to compare against.
  */
-type Filters<T> = Partial<{
+type Filters<T extends object = UnspecifiedRecord> = Partial<{
     [K in NestedKeyOf<T>]: unknown;
 }>;
 /**
@@ -36,7 +291,7 @@ type Filters<T> = Partial<{
  * @param index - The index of the row.
  * @returns True if the row matches the filter, false otherwise.
  */
-type FilterCallback<T> = (row: T, index: number) => boolean;
+type FilterCallback<T extends object = UnspecifiedRecord> = (row: T, index: number) => boolean;
 /**
  * Callback for filtering a field value against the filter data.
  * @param value - The value to filter.
@@ -72,7 +327,7 @@ type ColumnRole = 'display' | 'internal';
  * @param field - The field of the column.
  * @param row - The row data.
  */
-type CellPartsCallback<T> = (value: unknown, field: NestedKeyOf<T>, row: T) => string | string[] | undefined;
+type CellPartsCallback<T extends object = UnspecifiedRecord> = (value: unknown, field: NestedKeyOf<T>, row: T) => string | string[] | undefined;
 /**
  * Callback for providing the full contents of a rendered cell.
  * @param value - The value of the cell.
@@ -80,14 +335,14 @@ type CellPartsCallback<T> = (value: unknown, field: NestedKeyOf<T>, row: T) => s
  * @param row - The row data.
  * @returns - Should return an HTMLElement or anything Lit can render
  */
-type CellRenderCallback<T> = (value: unknown, field: NestedKeyOf<T>, row: T) => Renderable;
+type CellRenderCallback<T extends object = UnspecifiedRecord> = (value: unknown, field: NestedKeyOf<T>, row: T) => Renderable;
 /**
  * Callback for formatting the value of a cell.
  * Called when the cell is created and when exporting to CSV.
  * @param value - The value of the cell.
  * @param row - The row data.
  */
-type ValueFormatterCallback<T> = (value: unknown, row: T) => string | null;
+type ValueFormatterCallback<T extends object = UnspecifiedRecord> = (value: unknown, row: T) => string | null;
 /**
  * Callback for caching the sort value of a field
  * This function should derive a comparable value (often numerical or lowercase string) from the field's original value, to be used during sorting.
@@ -95,10 +350,44 @@ type ValueFormatterCallback<T> = (value: unknown, row: T) => string | null;
  * @returns The derived value for sorting (e.g., a number or a standardized string).
  */
 type SortValueCallback = (value: unknown) => Compareable;
+/**
+ *
+ */
+interface CellEditor<T extends object = UnspecifiedRecord> {
+    /**
+     * Reset the state of the editor before a new cell uses it
+     * @returns
+     */
+    reset: () => void;
+    /**
+     * A function to determine if editing should be allowed for the given row.
+     */
+    canEdit: (field: NestedKeyOf<T>, row: T) => boolean;
+    /**
+     * A method for rendering the input element used for editing the cell
+     * @param value - The current value
+     * @param field - The field that is being edited
+     * @param row  - The row
+     * @param controller - This table's controller
+     * @returns Should return a renderable object like TemplateResult
+     */
+    render: (value: unknown, field: NestedKeyOf<T>, row: T, controller: YatlTableController<T>) => unknown;
+    /**
+     * A method for saving the data. If it's async,
+     * the promise will be awaited before closing the edit.
+     * @param originalValue - The value before editing
+     * @param field The field that is being edited
+     * @param row The row that is being edited
+     * @param controller The table's controller
+     * @returns The new value or a promise to the new value.
+     * If undefined is returned, the edit is cancelled
+     */
+    save: (originalValue: unknown, field: NestedKeyOf<T>, row: T, controller: YatlTableController<T>) => MaybePromise<unknown | undefined>;
+}
 /**
  * Shared options between both internal and displayed columns.
  */
-interface BaseColumnOptions<T> {
+interface BaseColumnOptions<T extends object = UnspecifiedRecord> {
     /**
      * The field name in the data object.
      */
@@ -139,7 +428,7 @@ interface BaseColumnOptions<T> {
 /**
  * Column options for the table.
  */
-interface DisplayColumnOptions<T> extends BaseColumnOptions<T> {
+interface DisplayColumnOptions<T extends object = UnspecifiedRecord> extends BaseColumnOptions<T> {
     /**
      * Determines if a column is intended to be displayed,
      * or just for searching and filtering.
@@ -153,6 +442,10 @@ interface DisplayColumnOptions<T> extends BaseColumnOptions<T> {
      * Whether the column should be resizable.
      */
     resizable?: boolean;
+    /**
+     * Wheter the column's cells can be edited or not.
+     */
+    editor?: CellEditor<T>;
     /**
      * A function to format the value for display.
      */
@@ -170,14 +463,14 @@ interface DisplayColumnOptions<T> extends BaseColumnOptions<T> {
 /**
  * Internal column definition used for searching and filtering
  */
-interface InternalColumnOptions<T> extends BaseColumnOptions<T> {
+interface InternalColumnOptions<T extends object = UnspecifiedRecord> extends BaseColumnOptions<T> {
     /**
      * Marks this column as internal-only.
      * It will be indexed for search and filtering, but strictly excluded from the UI.
      */
     role: 'internal';
 }
-type ColumnOptions<T> = DisplayColumnOptions<T> | InternalColumnOptions<T>;
+type ColumnOptions<T extends object = UnspecifiedRecord> = DisplayColumnOptions<T> | InternalColumnOptions<T>;
 /**
  * Defines the possible sorting orders for columns.
  */
@@ -198,7 +491,7 @@ type SortState = {
 /**
  * Represents the current state of a column.
  */
-interface ColumnState<T> {
+interface ColumnState<T extends object = UnspecifiedRecord> {
     /**
      * The unique field name of the column.
      */
@@ -219,9 +512,9 @@ interface ColumnState<T> {
 /**
  * {@link ColumnState} with all properties optional except {@link ColumnState.field}
  */
-type RestorableColumnState<T> = Partial<Omit<ColumnState<T>, 'field'>> & Pick<ColumnState<T>, 'field'>;
+type RestorableColumnState<T extends object = UnspecifiedRecord> = Partial<Omit<ColumnState<T>, 'field'>> & Pick<ColumnState<T>, 'field'>;
 
-type RowIdCallback<T> = (row: T, index: number) => RowId;
+type RowIdCallback<T extends object = UnspecifiedRecord> = (row: T, index: number) => RowId;
 /**
  * The method used for selecting rows.
  * * single - Only a single row can be selected at a time
@@ -234,7 +527,11 @@ type RowSelectionMethod = 'single' | 'multi';
  * @param row - The row data.
  * @returns the part string or list of part strings that should be added to this row.
  */
-type RowPartsCallback<T> = (row: T) => string | string[] | undefined;
+type RowPartsCallback<T extends object = UnspecifiedRecord> = (row: T) => string | string[] | undefined;
+interface StorageInterface {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+}
 /**
  * Options used to configure what state information
  * should be saved and restored automatically.
@@ -245,12 +542,8 @@ interface StorageOptions {
      * * @example "my-app-users-table-v1"
      */
     key: string;
-    /**
-     * Which storage engine to use.
-     * * 'local': Persists after browser is closed (Default).
-     * * 'session': Cleared when tab is closed.
-     */
-    storage?: 'local' | 'session';
+    /** A storage client for getting and setting values. Defaults to window.localStorage */
+    storage?: StorageInterface;
     /** Save the current search query */
     saveSearchQuery?: boolean;
     /** Save the current column sorting */
@@ -267,7 +560,7 @@ interface StorageOptions {
 /**
  * Represents the current state of the table
  */
-interface TableState<T> {
+interface TableState<T extends object = UnspecifiedRecord> {
     /**
      * A list of {@link ColumnState}s representing all of the columns in the table.
      */
@@ -281,7 +574,7 @@ interface TableState<T> {
      */
     selectedRows: RowId[];
 }
-type RestorableTableState<T> = Partial<Omit<TableState<T>, 'columns'>> & {
+type RestorableTableState<T extends object = UnspecifiedRecord> = Partial<Omit<TableState<T>, 'columns'>> & {
     columns?: RestorableColumnState<T>[];
 };
 /**
@@ -298,9 +591,9 @@ interface ExportOptions {
 /**
  * Options for configuring a table controller
  */
-interface TableControllerOptions<T extends object> {
-    enableSearchTokenization?: boolean;
-    enableSearchScoring?: boolean;
+interface TableControllerOptions<T extends object = UnspecifiedRecord> {
+    tokenizedSearch?: boolean;
+    scoredSearch?: boolean;
     searchTokenizer?: TokenizerCallback;
     rowIdCallback?: RowIdCallback<T>;
     rowSelectionMethod?: RowSelectionMethod | null;
@@ -308,12 +601,182 @@ interface TableControllerOptions<T extends object> {
     columns?: ColumnOptions<T>[];
     data?: T[];
 }
+interface YatlTableControllerApi<T extends object = UnspecifiedRecord> {
+    /**
+     * The definitions for the columns to be rendered.
+     * This defines the field mapping, titles, sortability, and other static options.
+     */
+    columns: ColumnOptions<T>[];
+    /**
+     * The dynamic runtime state of the table's columns (visibility, width, and sort order).
+     *
+     * Unlike the static `columns` definitions, `columnStates` represents the current,
+     * interactive state of the grid. This is primarily used for programmatic control,
+     * or for saving and restoring user preferences (e.g., from `localStorage`).
+     */
+    columnStates: ColumnState<T>[];
+    /**
+     * The array of data objects to be displayed.
+     * Objects must satisfy the `WeakKey` constraint (objects only, no primitives).
+     */
+    data: T[];
+    /**
+     * An optional set of criteria to filter the visible rows.
+     * This runs **before** the global search query is applied.
+     * * You can provide:
+     * 1. A **Partial Object**: matches rows where specific keys equal specific values (AND logic).
+     * 2. A **Callback Function**: returns `true` to keep the row, `false` to hide it.
+     * * @example
+     * // 1. Object Syntax (Simple Exact Match)
+     * // Shows rows where status is 'active' AND role is 'admin'
+     * table.filters = { status: 'active', role: 'admin' };
+     * * @example
+     * // 2. Callback Syntax (Complex Logic)
+     * // Shows rows where age is over 21 OR they are a VIP
+     * table.filters = (row) => row.age > 21 || row.isVip;
+     */
+    filters: Filters<T> | FilterCallback<T> | null;
+    /**
+     * The current text string used to filter the table data.
+     * Setting this property triggers a new search and render cycle.
+     */
+    searchQuery: string;
+    /**
+     * Enables tokenized search behavior.
+     * When enabled, the search query is split into individual tokens using the
+     * `searchTokenizer` function (defaults to splitting on whitespace).
+     * A row is considered a match if **ANY** of the tokens appear in the searchable fields.
+     */
+    tokenizedSearch: boolean;
+    /**
+     * Enables weighted relevance scoring for search results.
+     * When enabled, exact matches and prefix matches are ranked higher than substring matches.
+     * Rows are sorted by their relevance score descending.
+     */
+    scoredSearch: boolean;
+    /**
+     * A function that splits the search query into tokens.
+     * Only used if search tokenization is enabled.
+     * @default whitespaceTokenizer
+     */
+    searchTokenizer: TokenizerCallback;
+    /**
+     * The row selection method to use.
+     * * single - Only a single row can be selected at a time
+     * * multi - Multiple rows can be selected at a time
+     * * null - Disable row selection
+     * @attr row-selection-method
+     */
+    rowSelectionMethod: RowSelectionMethod | null;
+    /**
+     * List of currently selected row indexes.
+     * * **NOTE**: These indexes are based off the of
+     * the original data array index, *not* the filtered data.
+     */
+    selectedRowIds: RowId[];
+    /**
+     * A callback function used to extract or generate a unique identifier for each row.
+     *
+     * A stable, unique ID is heavily relied upon by the grid engine for maintaining row selection
+     * state, tracking row metadata, and ensuring optimal rendering performance within the virtual
+     * scroller—especially when data is actively being sorted, filtered, or updated.
+     *
+     * **Default Behavior:** * If not provided, the table will automatically attempt to locate an `id`, `key`, or `_id`
+     * property on the row data object. If none are found, it falls back to using the row's original
+     * array index (which will trigger a console warning, as indices are inherently unstable during sorting).
+     *
+     * **Note:** Because this expects a JavaScript function, it is exposed strictly as a property
+     * and does not have a corresponding HTML attribute. You must use the property binding syntax
+     * (`.rowIdCallback`) in a Lit template.
+     *
+     * @example
+     * ```html
+     * * <yatl-table .rowIdCallback=${(row) => row.deviceUuid}></yatl-table>
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Programmatic assignment using a composite key
+     * table.rowIdCallback = (row, index) => `${row.chassisId}-${row.slotNumber}`;
+     * ```
+     */
+    rowIdCallback: RowIdCallback<T>;
+    /**
+     * Configuration options for automatically saving and restoring table state
+     * (column width, order, visibility, etc.) to the provided storage interface.
+     */
+    storageOptions: StorageOptions | null;
+}
+interface YatlTableApi<T extends object = UnspecifiedRecord> extends YatlTableControllerApi<T> {
+    /**
+     * The table controller to use for this table component.
+     */
+    controller: YatlTableController<T>;
+    /**
+     * Enables visual row striping
+     */
+    striped: boolean;
+    /**
+     * Default sortability for all columns.
+     * Can be overridden by setting `sortable` on the specific column definition.
+     *
+     * **NOTE:** Changing this will not clear sorted column states.
+     */
+    sortable: boolean;
+    /**
+     * Default resizability for all columns.
+     * Can be overridden by setting `resizable` on the specific column definition.
+     *
+     * **NOTE:** Changing this will not clear current column widths.
+     */
+    resizable: boolean;
+    /**
+     * Allows users to reorder columns by dragging and dropping headers.
+     */
+    reorderable: boolean;
+    /**
+     * When set, shows a column to the left of each row with its row number.
+     */
+    rowNumbers: boolean;
+    /**
+     * When set, only the visible rows are rendered to the DOM, significantly improving
+     * performance for large datasets (1000+ rows).
+     */
+    virtualScroll: boolean;
+    /**
+     * Hides the built-in footer row which displays the current record count.
+     * The footer content can be customized using the `slot="footer"` element.
+     */
+    hideFooter: boolean;
+    /**
+     * When set, completely disables editing for all columns.
+     */
+    disableEditing: boolean;
+    /**
+     * The string to display in a cell when the data value is `null` or `undefined`.
+     */
+    nullValuePlaceholder: string;
+    /**
+     * The message displayed when the `data` array is empty.
+     */
+    emptyMessage: string;
+    /**
+     * The message displayed when `data` exists but the current search/filter results in zero visible rows.
+     */
+    noResultsMessage: string;
+    /**
+     * A callback function to conditionally apply CSS parts to table rows.
+     */
+    rowParts: RowPartsCallback<T> | null;
+}
 
 /**
  * Base event class that bubbles and is composed.
  */
 declare abstract class YatlEvent extends Event {
     constructor(name: string, options?: EventInit);
+}
+declare abstract class YatlTableControllerEvent extends YatlEvent {
     abstract clone(): YatlEvent;
 }
 declare class YatlRowClickEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
@@ -324,7 +787,6 @@ declare class YatlRowClickEvent<T extends object = UnspecifiedRecord> extends Ya
     readonly originalEvent: MouseEvent;
     static readonly EVENT_NAME = "yatl-row-click";
     constructor(row: T, rowId: RowId, index: number, field: NestedKeyOf<T>, originalEvent: MouseEvent);
-    clone(): YatlRowClickEvent<T>;
 }
 declare class YatlRowSelectRequest extends YatlEvent {
     readonly rowId: RowId;
@@ -332,9 +794,8 @@ declare class YatlRowSelectRequest extends YatlEvent {
     readonly currentlySelectedRows: RowId[];
     static readonly EVENT_NAME = "yatl-row-select-request";
     constructor(rowId: RowId, selected: boolean, currentlySelectedRows: RowId[]);
-    clone(): YatlRowSelectRequest;
 }
-declare class YatlRowSelectEvent extends YatlEvent {
+declare class YatlRowSelectEvent extends YatlTableControllerEvent {
     readonly selectedIds: RowId[];
     readonly previouslySelectedRows: RowId[];
     static readonly EVENT_NAME = "yatl-row-select";
@@ -347,9 +808,8 @@ declare class YatlColumnSortRequest<T extends object = UnspecifiedRecord> extend
     readonly multisort: boolean;
     static readonly EVENT_NAME = "yatl-column-sort-request";
     constructor(field: NestedKeyOf<T>, order: SortOrder | null, multisort: boolean);
-    clone(): YatlColumnSortRequest<T>;
 }
-declare class YatlColumnSortEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlColumnSortEvent<T extends object = UnspecifiedRecord> extends YatlTableControllerEvent {
     readonly field: NestedKeyOf<T>;
     readonly order: SortOrder | null;
     readonly multisort: boolean;
@@ -357,14 +817,14 @@ declare class YatlColumnSortEvent<T extends object = UnspecifiedRecord> extends
     constructor(field: NestedKeyOf<T>, order: SortOrder | null, multisort: boolean);
     clone(): YatlColumnSortEvent<T>;
 }
-declare class YatlColumnToggleEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlColumnToggleEvent<T extends object = UnspecifiedRecord> extends YatlTableControllerEvent {
     readonly field: NestedKeyOf<T>;
     readonly visible: boolean;
     static readonly EVENT_NAME = "yatl-column-toggle";
     constructor(field: NestedKeyOf<T>, visible: boolean);
     clone(): YatlColumnToggleEvent<T>;
 }
-declare class YatlColumnResizeEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlColumnResizeEvent<T extends object = UnspecifiedRecord> extends YatlTableControllerEvent {
     readonly field: NestedKeyOf<T>;
     readonly width: number | null;
     static readonly EVENT_NAME = "yatl-column-resize";
@@ -377,27 +837,35 @@ declare class YatlColumnReorderRequest<T extends object = UnspecifiedRecord> ext
     readonly newIndex: number;
     static readonly EVENT_NAME = "yatl-column-reorder-request";
     constructor(movedColumn: NestedKeyOf<T>, originalIndex: number, newIndex: number);
-    clone(): YatlColumnReorderRequest<T>;
 }
-declare class YatlColumnReorderEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlColumnReorderEvent<T extends object = UnspecifiedRecord> extends YatlTableControllerEvent {
     readonly order: NestedKeyOf<T>[];
     static readonly EVENT_NAME = "yatl-column-reorder";
     constructor(order: NestedKeyOf<T>[]);
     clone(): YatlColumnReorderEvent<T>;
 }
-declare class YatlTableSearchEvent extends YatlEvent {
+declare class YatlCellEditEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+    readonly row: T;
+    readonly rowId: RowId;
+    readonly field: NestedKeyOf<T>;
+    readonly originalValue: unknown;
+    readonly currentValue: unknown;
+    static readonly EVENT_NAME = "yatl-cell-edit";
+    constructor(row: T, rowId: RowId, field: NestedKeyOf<T>, originalValue: unknown, currentValue: unknown);
+}
+declare class YatlTableSearchEvent extends YatlTableControllerEvent {
     readonly query: string;
     static readonly EVENT_NAME = "yatl-table-search";
     constructor(query: string);
     clone(): YatlTableSearchEvent;
 }
-declare class YatlTableViewChangeEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlTableViewChangeEvent<T extends object = UnspecifiedRecord> extends YatlTableControllerEvent {
     readonly data: T[];
     static readonly EVENT_NAME = "yatl-table-view-change";
     constructor(data: T[]);
     clone(): YatlTableViewChangeEvent<T>;
 }
-declare class YatlTableStateChangeEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlTableStateChangeEvent<T extends object = UnspecifiedRecord> extends YatlTableControllerEvent {
     readonly state: TableState<T>;
     readonly triggers: string[];
     static readonly EVENT_NAME = "yatl-table-state-change";
@@ -421,115 +889,135 @@ declare global {
     }
 }
 
-declare class TypedEventTarget<TEventMap extends Record<string, Event>> extends EventTarget {
-    addEventListener<K extends keyof TEventMap>(type: K, listener: (this: TEventMap, ev: TEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
-    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<K extends keyof TEventMap>(type: K, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
-    dispatchEvent<K extends keyof TEventMap>(event: TEventMap[K]): boolean;
+interface BaseEditorOptions<T extends object = UnspecifiedRecord> {
+    canEdit?: (field: NestedKeyOf<T>, row: T) => boolean;
+    onSave?: (oldValue: unknown, newValue: unknown, field: NestedKeyOf<T>, row: T) => MaybePromise<unknown | undefined>;
+}
+declare abstract class BaseEditor<T extends object = UnspecifiedRecord> implements CellEditor<T> {
+    protected readonly options?: BaseEditorOptions<T> | undefined;
+    protected currentValue: unknown;
+    constructor(options?: BaseEditorOptions<T> | undefined);
+    reset(): void;
+    canEdit(field: NestedKeyOf<T>, row: T): boolean;
+    abstract render(value: unknown, field: NestedKeyOf<T>, row: T, controller: YatlTableController<T>): unknown;
+    save(originalValue: unknown, field: NestedKeyOf<T>, row: T, _controller: YatlTableController<T>): unknown;
 }
 
-declare class YatlTableController<T extends object = UnspecifiedRecord> extends TypedEventTarget<ControllerEventMap> implements ReactiveController {
-    private hosts;
-    private _enableSearchTokenization;
-    private _enableSearchScoring;
-    private _columns;
-    private _columnDefinitionMap;
-    private _columnStateMap;
-    private _rowSelectionMethod;
-    private _selectedRowIds;
-    private _storageOptions;
-    private _rowIdCallback;
-    private _data;
-    private _filteredData;
-    private _dataUpdateTimestamp;
-    private _searchQuery;
-    private _searchTokenizer;
-    private _filters;
-    private hasRestoredState;
-    private saveTimer;
-    private filterDirty;
-    private sortDirty;
-    private rowMetadata;
-    private idToRowMap;
-    private queryTokens;
-    /**
-     * Enables tokenized search behavior.
-     * When enabled, the search query is split into individual tokens using the
-     * `searchTokenizer` function (defaults to splitting on whitespace).
-     * A row is considered a match if **ANY** of the tokens appear in the searchable fields.
-     * @default false
-     */
-    get enableSearchTokenization(): boolean;
-    set enableSearchTokenization(enable: boolean);
-    /**
-     * Enables weighted relevance scoring for search results.
-     * When enabled, exact matches and prefix matches are ranked higher than substring matches.
-     * Rows are sorted by their relevance score descending.
-     * @default false
-     */
-    get enableSearchScoring(): boolean;
-    set enableSearchScoring(enable: boolean);
-    /**
-     * The definitions for the columns to be rendered.
-     * This defines the field mapping, titles, sortability, and other static options.
-     */
+declare class InputEditor<T extends object = UnspecifiedRecord> extends BaseEditor<T> {
+    readonly options?: InputEditorOptions<T> | undefined;
+    constructor(options?: InputEditorOptions<T> | undefined);
+    render(value: unknown, _field: NestedKeyOf<T>, _row: T, _controller: YatlTableController<T>): lit_html.TemplateResult<1>;
+    private handleChange;
+}
+type InputType = 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'month' | 'number' | 'range' | 'tel' | 'text' | 'time' | 'url' | 'week';
+interface InputEditorOptions<T extends object = UnspecifiedRecord> extends BaseEditorOptions<T> {
+    type?: InputType;
+    minlength?: number;
+    maxlength?: number;
+    min?: number | string;
+    max?: number | string;
+    step?: number;
+    pattern?: string;
+    placeholder?: string;
+}
+
+interface NumberEditorOptions<T extends object = UnspecifiedRecord> extends BaseEditorOptions<T> {
+    min?: number;
+    max?: number;
+    step?: number;
+}
+declare class NumberEditor<T extends object = UnspecifiedRecord> extends InputEditor<T> {
+    constructor(options?: NumberEditorOptions<T>);
+}
+
+declare class SelectEditor<T extends object = UnspecifiedRecord> extends BaseEditor<T> {
+    protected readonly options?: SelectEditorOptions<T> | undefined;
+    constructor(options?: SelectEditorOptions<T> | undefined);
+    render(value: unknown, field: NestedKeyOf<T>, row: T, controller: YatlTableController<T>): lit_html.TemplateResult<1>;
+    renderOption(option: unknown, select: boolean): lit_html.TemplateResult<1>;
+    private handleChange;
+}
+interface SelectEditorOptions<T extends object = UnspecifiedRecord> extends BaseEditorOptions<T> {
+    labelRenderer?: (value: unknown) => [string, string];
+}
+
+interface TextEditorOptions<T extends object = UnspecifiedRecord> extends BaseEditorOptions<T> {
+    minlength?: number;
+    maxlength?: number;
+    pattern?: string;
+    placeholder?: string;
+}
+declare class TextEditor<T extends object = UnspecifiedRecord> extends InputEditor<T> {
+    constructor(options?: TextEditorOptions<T>);
+}
+
+/**
+ * A virtualized data table capable of handling complex sorting, filtering, and tokenized searching.
+ *
+ * @element yatl-table
+ * @summary A high-performance grid engine for rugged environments.
+ *
+ * @fires yatl-cell-edit - Fired after a cell value has been edited.
+ * @fires yatl-row-click - Fired when a user clicks a row.
+ * @fires yatl-row-select-request - Fired before the row selection changes. Cancellable
+ * @fires yatl-row-select - Fired when the row selection changes.
+ * @fires yatl-column-sort-request - Fired before a column sort order changes. Cancellable.
+ * @fires yatl-column-sort - Fired when a column sort order changes.
+ * @fires yatl-column-toggle - Fired when a column's visibility changes.
+ * @fires yatl-column-resize - Fired after a column has been resized by the user.
+ * @fires yatl-column-reorder-request - Fired when the user drops a column into a new position. Cancellable.
+ * @fires yatl-column-reorder - Fired after the column order changes.
+ * @fires yatl-table-search - Fired when the search query is updated.
+ * @fires yatl-table-view-change - Fired when the visible slice of data changes due to sorting, filtering, or data updates. Payload contains the processed rows.
+ * @fires yatl-table-state-change - Fired when any persistable state (width, order, sort, query) changes. Used for syncing with local storage.
+ */
+declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement implements YatlTableApi<T> {
+    static styles: lit.CSSResult[];
+    private tableElement;
+    private virtualizer?;
+    private editor?;
+    private get virtualizerRef();
+    private resizeState;
+    private dragColumn;
+    private useYatlUi;
+    private editingState;
+    private _controller;
+    get controller(): YatlTableController<T>;
+    set controller(controller: YatlTableController<T>);
     get columns(): ColumnOptions<T>[];
     set columns(columns: ColumnOptions<T>[]);
+    /**
+     * Gets a list of columns with the display role
+     * **This will always be ordered the same as the visual column order**
+     */
     get displayColumns(): DisplayColumnOptions<T>[];
     get columnStates(): ColumnState<T>[];
     set columnStates(states: ColumnState<T>[]);
-    /**
-     * The current text string used to filter the table data.
-     * Setting this property triggers a new search and render cycle.
-     */
+    get data(): T[];
+    set data(value: T[]);
+    get filteredData(): T[];
+    get dataUpdateTimestamp(): Date | null;
+    get filters(): Partial<{ [K in NestedKeyOf<T>]: unknown; }> | FilterCallback<T> | null;
+    set filters(filters: Partial<{ [K in NestedKeyOf<T>]: unknown; }> | FilterCallback<T> | null);
+    /** @attr search-query */
     get searchQuery(): string;
     set searchQuery(query: string);
-    /**
-     * A function that splits the search query into tokens.
-     * Only used if `enableSearchTokenization` is true.
-     * @default whitespaceTokenizer
-     */
+    /** @attr tokenized-search */
+    get tokenizedSearch(): boolean;
+    set tokenizedSearch(enable: boolean);
+    /** @attr scored-search */
+    get scoredSearch(): boolean;
+    set scoredSearch(enable: boolean);
     get searchTokenizer(): TokenizerCallback;
     set searchTokenizer(tokenizer: TokenizerCallback);
-    /**
-     * An optional set of criteria to filter the visible rows.
-     * This runs **before** the global search query is applied.
-     * * You can provide:
-     * 1. A **Partial Object**: matches rows where specific keys equal specific values (AND logic).
-     * 2. A **Callback Function**: returns `true` to keep the row, `false` to hide it.
-     * * @example
-     * // 1. Object Syntax (Simple Exact Match)
-     * // Shows rows where status is 'active' AND role is 'admin'
-     * table.filters = { status: 'active', role: 'admin' };
-     * * @example
-     * // 2. Callback Syntax (Complex Logic)
-     * // Shows rows where age is over 21 OR they are a VIP
-     * table.filters = (row) => row.age > 21 || row.isVip;
-     */
-    get filters(): Partial<{ [K in NestedKeyOf<T>]: unknown; }> | FilterCallback<T> | null;
-    set filters(filters: Partial<{ [K in NestedKeyOf<T>]: unknown; }> | FilterCallback<T> | null);
-    /**
-     * The row selection method to use.
-     * * single - Only a single row can be selected at a time
-     * * multi - Multiple rows can be selected at a time
-     * * null - Disable row selection
-     */
+    /** @attr row-selection-method */
     get rowSelectionMethod(): RowSelectionMethod | null;
     set rowSelectionMethod(selection: RowSelectionMethod | null);
-    /**
-     * List of currently selected row indexes.
-     * * **NOTE**: These indexes are based off the of
-     * the original data array index, *not* the filtered data.
-     */
     get selectedRowIds(): RowId[];
     set selectedRowIds(rows: RowId[]);
-    /**
-     * Configuration options for automatically saving and restoring table state
-     * (column width, order, visibility, etc.) to browser storage.
-     */
     get storageOptions(): {
         key: string;
-        storage?: "local" | "session";
+        storage?: StorageInterface;
         saveSearchQuery?: boolean;
         saveColumnSortOrders?: boolean;
         saveColumnVisibility?: boolean;
@@ -539,7 +1027,7 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> extends
     } | null;
     set storageOptions(options: {
         key: string;
-        storage?: "local" | "session";
+        storage?: StorageInterface;
         saveSearchQuery?: boolean;
         saveColumnSortOrders?: boolean;
         saveColumnVisibility?: boolean;
@@ -549,393 +1037,34 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> extends
     } | null);
     get rowIdCallback(): RowIdCallback<T>;
     set rowIdCallback(callback: RowIdCallback<T>);
-    /**
-     * The array of data objects to be displayed.
-     * Objects must satisfy the `WeakKey` constraint (objects only, no primitives).
-     */
-    get data(): T[];
-    set data(data: T[]);
-    get filteredData(): T[];
-    get dataUpdateTimestamp(): Date | null;
-    constructor(host?: ReactiveControllerHost, options?: TableControllerOptions<T>);
-    attach(host: ReactiveControllerHost): void;
-    detach(host: ReactiveControllerHost): void;
-    getColumn(field: NestedKeyOf<T>): ColumnOptions<T> | undefined;
-    getDisplayColumn(field: NestedKeyOf<T>): DisplayColumnOptions<T> | undefined;
-    /**
-     * Gets a copy of the current state of the table.
-     */
-    getTableState(): TableState<T>;
-    /**
-     * Restores the table to the provided state.
-     * @param state - The state to restore the table to.
-     */
-    updateTableState(state: RestorableTableState<T>): void;
-    getColumnState(field: NestedKeyOf<T>): ColumnState<T>;
-    updateColumnState(field: NestedKeyOf<T>, state: RestorableColumnState<T>): void;
-    search(query: string): void;
-    getColumnFilterValues(field: NestedKeyOf<T>, includeNull?: boolean): Map<unknown, number>;
-    /**
-     * Sorts the table by a specified column and order.
-     * If `order` is `null`, the sort on this column is removed.
-     * @param field - The field name of the column to sort by.
-     * @param order - The sort order: 'asc', 'desc', or `null` to remove sorting for this column.
-     * @param clear - Clear all other sorting
-     */
-    sort(field: NestedKeyOf<T>, order: SortOrder | null, clear?: boolean): void;
-    /**
-     * Toggles the visibility of hte specified column
-     * @param field - The field name of the column to toggle.
-     * @param visible - Optionally force the visibility state.
-     */
-    toggleColumnVisibility(field: NestedKeyOf<T>, visible?: boolean): void;
-    /**
-     * Shows the specified column
-     * @param field - The field name of the column to show.
-     */
-    showColumn(field: NestedKeyOf<T>): void;
-    /**
-     * Hides the specified column
-     * @param field - The field name of the column to hide.
-     */
-    hideColumn(field: NestedKeyOf<T>): void;
-    /**
-     * Moves a column to a new position
-     * @param field - The column to move
-     * @param newPosition The index or field of the column to move it to.
-     * @returns
-     */
-    moveColumn(field: NestedKeyOf<T>, newPosition: number | NestedKeyOf<T>): void;
-    resizeColumn(field: NestedKeyOf<T>, width: number | null): void;
-    isRowSelected(row: T): boolean;
-    /**
-     * Toggles the selection state of a specific row.
-     */
-    toggleRowSelection(row: T, state?: boolean): void;
-    /**
-     * Selects a specific row.
-     */
-    selectRow(row: T): void;
-    /**
-     * Deselects a specific row.
-     */
-    deselectRow(row: T): void;
-    /**
-     * Selects all currently visible rows (for "Select All" checkbox).
-     */
-    selectAll(): void;
-    /**
-     * Clears all selection.
-     */
-    deselectAll(): void;
-    /**
-     * Export the current visible table data to a CSV file.
-     * @param options - Options for configuring what should be exported.
-     */
-    export(options?: ExportOptions): Blob;
-    /**
-     * Gets the row associated with the provided ID.
-     * @param id - The ID of the row to get
-     * @returns
-     */
-    getRow(id: RowId): T | undefined;
-    /**
-     * Finds the first row where {@link field} matches {@link value}
-     * @param field - The field name within the row data to search.
-     * @param value - The value to match against the field's content.
-     * @returns The found row, or undefined if no match is found.
-     */
-    findRow(field: NestedKeyOf<T>, value: unknown): T | undefined;
-    /**
-     * Finds the original index of the first row where the specified field matches the given value.
-     * This searches through the original, unfiltered dataset.
-     * @param field - The field name within the row data to search.
-     * @param value - The value to match against the field's content.
-     * @returns The original index of the found row, or -1 if no match is found.
-     * @example
-     * ```ts
-     * const index = dataTable.indexOf('id', 12345);
-     * if (index >= 0) {
-     *  dataTable.updateRow({description: "Updated description"}, index);
-     * }
-     * ```
-     */
-    findRowIndex(field: NestedKeyOf<T>, value: unknown): number;
-    updateRow(rowId: RowId, data: Partial<T>): void;
-    /**
-     * Updates the data of a row at a specific original index.
-     * @param index - The original index of the row to update.
-     * @param data - An object containing the new data to assign to the row. Existing fields will be updated, and new fields will be added.
-     *
-     * @example
-     * ```ts
-     * const index = dataTable.indexOf('id', 12345);
-     * if (index >= 0) {
-     *  dataTable.updateRow(index, {description: "Updated description"});
-     * }
-     * ```
-     */
-    updateRowAtIndex(index: number, data: Partial<T>): void;
-    /**
-     * Deletes the row with the matching ID.
-     * @param rowIds - The IDs rows to delete
-     */
-    deleteRow(...rowIds: RowId[]): void;
-    /**
-     * Deletes a row at a specific original index from the table.
-     * @param indexes - The original indexes of rows to delete.
-     */
-    deleteRowAtIndex(...indexes: number[]): void;
-    getRowId(row: T): RowId;
-    getRowIndex(row: T): number;
-    getRowHighlightIndicies(row: T): Record<string, [number, number][]> | undefined;
-    hostConnected(): void;
-    hostDisconnected(): void;
-    hostUpdate(): void;
-    hostUpdated(): void;
-    requestUpdate(...props: (keyof YatlTableController)[]): void;
-    /**
-     * Calculates a relevance score for a given query against a target string.
-     *
-     * This function implements a tiered matching strategy:
-     * 1.  **Exact Match**: The query exactly matches the target. This yields the highest score.
-     * 2.  **Prefix Match**: The target starts with the query. This is the next most relevant.
-     * 3.  **Substring Match**: The target contains the query somewhere. This is the least relevant.
-     *
-     * The final score is weighted and adjusted by the length difference between the query and the target
-     * to ensure that more specific matches (e.g., "apple" vs "application" for the query "apple") rank higher.
-     *
-     * @param query The search term (e.g., "app").
-     * @param target The string to be searched (e.g., "Apple" or "Application").
-     * @returns A numerical score representing the relevance of the match. Higher is better. Returns 0 if no match is found.
-     */
-    private calculateSearchScore;
-    private searchField;
-    private filterField;
-    private filterRow;
-    private filterRows;
-    private compareRows;
-    private sortRows;
-    private createMetadata;
-    private updateInternalQuery;
-    private scheduleSave;
-    private saveStateToStorage;
-    private loadStateFromStorage;
-}
-type ControllerEventMap = {
-    [YatlColumnReorderEvent.EVENT_NAME]: YatlColumnReorderEvent;
-    [YatlColumnResizeEvent.EVENT_NAME]: YatlColumnResizeEvent;
-    [YatlColumnSortEvent.EVENT_NAME]: YatlColumnSortEvent;
-    [YatlColumnToggleEvent.EVENT_NAME]: YatlColumnToggleEvent;
-    [YatlRowSelectEvent.EVENT_NAME]: YatlRowSelectEvent;
-    [YatlTableSearchEvent.EVENT_NAME]: YatlTableSearchEvent;
-    [YatlTableStateChangeEvent.EVENT_NAME]: YatlTableStateChangeEvent;
-    [YatlTableViewChangeEvent.EVENT_NAME]: YatlTableViewChangeEvent;
-};
-
-/**
- * A virtualized data table capable of handling complex sorting, filtering, and tokenized searching.
- *
- * @element yatl-table
- * @summary A high-performance grid engine for rugged environments.
- *
- * @fires yatl-row-click - Fired when a user clicks a row.
- * @fires yatl-row-select-request - Fired before the row selection changes. Cancellable
- * @fires yatl-row-select - Fired when the row selection changes.
- * @fires yatl-column-sort-request - Fired before a column sort order changes. Cancellable.
- * @fires yatl-column-sort - Fired when a column sort order changes.
- * @fires yatl-column-toggle - Fired when a column's visibility changes.
- * @fires yatl-column-resize - Fired after a column has been resized by the user.
- * @fires yatl-column-reorder-request - Fired when the user drops a column into a new position. Cancellable.
- * @fires yatl-column-reorder - Fired after the column order changes.
- * @fires yatl-table-search - Fired when the search query is updated.
- * @fires yatl-table-view-change - Fired when the visible slice of data changes due to sorting, filtering, or data updates. Payload contains the processed rows.
- * @fires yatl-table-state-change - Fired when any persistable state (width, order, sort, query) changes. Used for syncing with local storage.
- */
-declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement {
-    static styles: lit.CSSResult[];
-    private tableElement;
-    private virtualizer?;
-    private get virtualizerRef();
-    private resizeState;
-    private dragColumn;
-    private useYatlUi;
-    private _controller;
-    get controller(): YatlTableController<T>;
-    set controller(controller: YatlTableController<T>);
     striped: boolean;
-    /**
-     * Default sortability for all columns.
-     * Can be overridden by setting `sortable` on the specific column definition.
-     * * **NOTE:** Changing this will not clear sorted column states.
-     * @default false
-     */
     sortable: boolean;
-    /**
-     * Default resizability for all columns.
-     * Can be overridden by setting `resizable` on the specific column definition.
-     * *  **NOTE:** Changing this will not clear current column widths.
-     * @default false
-     */
     resizable: boolean;
+    reorderable: boolean;
+    /** @attr row-numbers */
+    rowNumbers: boolean;
+    /** @attr virtual-scroll */
+    virtualScroll: boolean;
+    /** @attr hide-footer */
+    hideFooter: boolean;
+    /** @attr disable-editing */
+    disableEditing: boolean;
     /**
-     * Enables virtual scrolling for the table.
-     * When enabled, only the visible rows are rendered to the DOM, significantly improving
-     * performance for large datasets (1000+ rows).
-     * @default false
-     */
-    enableVirtualScroll: boolean;
-    /**
-     * When enabled, text matching the current search query will be wrapped in `<mark>` tags.
-     * This applies to all visible cells that contain the search term.
-     * This does NOT apply to content rendered by the user such as the ColumnOptions.render callback.
-     * @default true
-     */
-    enableSearchHighlight: boolean;
-    /**
-     * Enables tokenized search behavior.
-     * When enabled, the search query is split into individual tokens using the
-     * `searchTokenizer` function (defaults to splitting on whitespace).
-     * A row is considered a match if **ANY** of the tokens appear in the searchable fields.
-     * @default false
-     */
-    get enableSearchTokenization(): boolean;
-    set enableSearchTokenization(enable: boolean);
-    /**
-     * Enables weighted relevance scoring for search results.
-     * When enabled, exact matches and prefix matches are ranked higher than substring matches.
-     * Rows are sorted by their relevance score descending.
-     * @default false
-     */
-    get enableSearchScoring(): boolean;
-    set enableSearchScoring(enable: boolean);
-    /**
-     * Allows users to reorder columns by dragging and dropping headers.
-     * @default true
-     */
-    enableColumnReorder: boolean;
-    /**
-     * Shows a column to the left of each row with its row number.
-     */
-    enableRowNumberColumn: boolean;
-    /**
-     * Shows the built-in footer row which displays the current record count.
-     * The footer content can be customized using the `slot="footer"` element.
-     * @default false
-     */
-    enableFooter: boolean;
-    /**
-     * The string to display in a cell when the data value is `null` or `undefined`.
      * @default "-"
+     * @attr null-value-placeholder
      */
     nullValuePlaceholder: string;
     /**
-     * The message displayed when the `data` array is empty.
      * @default "No records to display"
+     * @attr emptry-message
      */
     emptyMessage: string;
     /**
-     * The message displayed when `data` exists but the current search/filter
-     * results in zero visible rows.
      * @default "No matching records found"
+     * @attr no-results-message
      */
     noResultsMessage: string;
-    /**
-     * The definitions for the columns to be rendered.
-     * This defines the field mapping, titles, sortability, and other static options.
-     */
-    get columns(): ColumnOptions<T>[];
-    set columns(columns: ColumnOptions<T>[]);
-    /**
-     * Gets a list of columns with the display role
-     * **This will always be ordered the same as the visual column order**
-     */
-    get displayColumns(): DisplayColumnOptions<T>[];
-    get columnStates(): ColumnState<T>[];
-    set columnStates(states: ColumnState<T>[]);
-    /**
-     * The current text string used to filter the table data.
-     * Setting this property triggers a new search and render cycle.
-     */
-    get searchQuery(): string;
-    set searchQuery(query: string);
-    /**
-     * A function that splits the search query into tokens.
-     * Only used if `enableSearchTokenization` is true.
-     * @default whitespaceTokenizer
-     */
-    get searchTokenizer(): TokenizerCallback;
-    set searchTokenizer(tokenizer: TokenizerCallback);
-    /**
-     * An optional set of criteria to filter the visible rows.
-     * This runs **before** the global search query is applied.
-     * * You can provide:
-     * 1. A **Partial Object**: matches rows where specific keys equal specific values (AND logic).
-     * 2. A **Callback Function**: returns `true` to keep the row, `false` to hide it.
-     * * @example
-     * // 1. Object Syntax (Simple Exact Match)
-     * // Shows rows where status is 'active' AND role is 'admin'
-     * table.filters = { status: 'active', role: 'admin' };
-     * * @example
-     * // 2. Callback Syntax (Complex Logic)
-     * // Shows rows where age is over 21 OR they are a VIP
-     * table.filters = (row) => row.age > 21 || row.isVip;
-     */
-    get filters(): Partial<{ [K in NestedKeyOf<T>]: unknown; }> | FilterCallback<T> | null;
-    set filters(filters: Partial<{ [K in NestedKeyOf<T>]: unknown; }> | FilterCallback<T> | null);
-    /**
-     * A callback function to conditionally apply CSS parts to table rows.
-     */
     rowParts: RowPartsCallback<T> | null;
-    /**
-     * The row selection method to use.
-     * * single - Only a single row can be selected at a time
-     * * multi - Multiple rows can be selected at a time
-     * * null - Disable row selection
-     */
-    get rowSelectionMethod(): RowSelectionMethod | null;
-    set rowSelectionMethod(selection: RowSelectionMethod | null);
-    /**
-     * List of currently selected row indexes.
-     * * **NOTE**: These indexes are based off the of
-     * the original data array index, *not* the filtered data.
-     */
-    get selectedRowIds(): RowId[];
-    set selectedRowIds(rows: RowId[]);
-    /**
-     * Configuration options for automatically saving and restoring table state
-     * (column width, order, visibility, etc.) to browser storage.
-     */
-    get storageOptions(): {
-        key: string;
-        storage?: "local" | "session";
-        saveSearchQuery?: boolean;
-        saveColumnSortOrders?: boolean;
-        saveColumnVisibility?: boolean;
-        saveColumnWidths?: boolean;
-        saveColumnOrder?: boolean;
-        saveSelectedRows?: boolean;
-    } | null;
-    set storageOptions(options: {
-        key: string;
-        storage?: "local" | "session";
-        saveSearchQuery?: boolean;
-        saveColumnSortOrders?: boolean;
-        saveColumnVisibility?: boolean;
-        saveColumnWidths?: boolean;
-        saveColumnOrder?: boolean;
-        saveSelectedRows?: boolean;
-    } | null);
-    get rowIdCallback(): RowIdCallback<T>;
-    set rowIdCallback(callback: RowIdCallback<T>);
-    /**
-     * The array of data objects to be displayed.
-     * Objects must satisfy the `WeakKey` constraint (objects only, no primitives).
-     */
-    get data(): T[];
-    set data(value: T[]);
-    get filteredData(): T[];
-    get dataUpdateTimestamp(): Date | null;
     getColumn(field: NestedKeyOf<T>): ColumnOptions<T> | undefined;
     getDisplayColumn(field: NestedKeyOf<T>): DisplayColumnOptions<T> | undefined;
     /**
@@ -1008,6 +1137,7 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
      * @param options - Options for configuring what should be exported.
      */
     export(filename: string, options?: ExportOptions): void;
+    print(title?: string): Promise<void>;
     scrollToRow(row: T): Promise<void>;
     /**
      * Scrolls the table to bring the row at the specified original index into view.
@@ -1077,9 +1207,9 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
      * @param index - The original index of the row to delete.
      */
     deleteRowAtIndex(index: number): void;
-    protected renderColumnSortIcon(column: DisplayColumnOptions<T>, state: ColumnState<T>): TemplateResult<1> | typeof nothing;
-    protected renderColumnResizer(column: DisplayColumnOptions<T>, _state: ColumnState<T>): TemplateResult<1> | typeof nothing;
-    protected renderHeaderCell(column: DisplayColumnOptions<T>): TemplateResult<1> | typeof nothing;
+    protected renderColumnSortIcon(column: DisplayColumnOptions<T>, state: ColumnState<T>): typeof nothing | TemplateResult<1>;
+    protected renderColumnResizer(column: DisplayColumnOptions<T>, _state: ColumnState<T>): typeof nothing | TemplateResult<1>;
+    protected renderHeaderCell(column: DisplayColumnOptions<T>): typeof nothing | TemplateResult<1>;
     protected renderRowNumberHeader(): TemplateResult<1>;
     protected renderSelectionHeader(): TemplateResult<1>;
     protected renderHeader(): TemplateResult<1>;
@@ -1090,11 +1220,12 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
     protected renderRowNumberCell(rowNumber: number): TemplateResult<1>;
     protected renderRow(row: T, renderIndex: number): TemplateResult<1>;
     protected renderBodyContents(): TemplateResult<1>;
-    protected renderFooter(): TemplateResult<1> | typeof nothing;
+    protected renderFooter(): typeof nothing | TemplateResult<1>;
     protected render(): TemplateResult<1>;
     private renderCellWrapper;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    updated(changedProperties: PropertyValues): void;
     private readonly eventNames;
     private addControllerListeners;
     private removeControllerListeners;
@@ -1105,8 +1236,14 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
      * order they will appear in the grid.
      */
     private getGridWidths;
+    private getInputTypeFromValue;
+    private getNextEditableField;
+    private saveEdits;
     private handleHeaderClicked;
     private handleCellClick;
+    private handleCellDoubleClick;
+    private handleCellInputKeypress;
+    private handleMouseDown;
     private handleResizeMouseDown;
     private handleResizeMouseMove;
     private handleResizeMouseUp;
@@ -1127,10 +1264,10 @@ declare global {
 declare function findColumn<TData extends Record<string, unknown>, TCol extends {
     field: NestedKeyOf<TData>;
 }>(columns: TCol[], field: NestedKeyOf<TData>): TCol | undefined;
-declare function isInternalColumn<T>(col: ColumnOptions<T> | undefined | null): col is InternalColumnOptions<T>;
-declare function isDisplayColumn<T>(col: ColumnOptions<T> | undefined | null): col is DisplayColumnOptions<T>;
-declare function createState<T>(field: NestedKeyOf<T>, defaults?: Partial<ColumnState<T>>): ColumnState<T>;
-declare function getColumnStateChanges<T>(oldState: ColumnState<T> | undefined, newState: ColumnState<T>): (keyof ColumnState<T>)[];
+declare function isInternalColumn<T extends object = UnspecifiedRecord>(col: ColumnOptions<T> | undefined | null): col is InternalColumnOptions<T>;
+declare function isDisplayColumn<T extends object = UnspecifiedRecord>(col: ColumnOptions<T> | undefined | null): col is DisplayColumnOptions<T>;
+declare function createState<T extends object = UnspecifiedRecord>(field: NestedKeyOf<T>, defaults?: Partial<ColumnState<T>>): ColumnState<T>;
+declare function getColumnStateChanges<T extends object = UnspecifiedRecord>(oldState: ColumnState<T> | undefined, newState: ColumnState<T>): (keyof ColumnState<T>)[];
 
 declare function isRowIdType(value: unknown): value is RowId;
 declare function isRowSelectionMethod(value: string | null): value is RowSelectionMethod;
@@ -1152,4 +1289,4 @@ declare const whitespaceTokenizer: (value: string) => {
     quoted: boolean;
 }[];
 
-export { type BaseColumnOptions, type CellPartsCallback, type CellRenderCallback, type ColumnFilterCallback, type ColumnOptions, type ColumnRole, type ColumnState, type Compareable, type ControllerEventMap, type DisplayColumnOptions, type ExportOptions, type FilterCallback, type Filters, type InternalColumnOptions, type NestedKeyOf, type QueryToken, type Renderable, type RestorableColumnState, type RestorableTableState, type RowId, type RowIdCallback, type RowPartsCallback, type RowSelectionMethod, type SortOrder, type SortState, type SortValueCallback, type StorageOptions, type TableControllerOptions, type TableState, type TokenizerCallback, TypedEventTarget, type UnspecifiedRecord, type ValueFormatterCallback, YatlColumnReorderEvent, YatlColumnReorderRequest, YatlColumnResizeEvent, YatlColumnSortEvent, YatlColumnSortRequest, YatlColumnToggleEvent, YatlEvent, YatlRowClickEvent, YatlRowSelectEvent, YatlRowSelectRequest, YatlTable, YatlTableController, YatlTableSearchEvent, YatlTableStateChangeEvent, YatlTableViewChangeEvent, createRegexTokenizer, createState, findColumn, getColumnStateChanges, getNestedValue, isDisplayColumn, isInternalColumn, isRowIdType, isRowSelectionMethod, setNestedValue, whitespaceTokenizer };
+export { type BaseColumnOptions, type CellEditor, type CellPartsCallback, type CellRenderCallback, type ColumnFilterCallback, type ColumnOptions, type ColumnRole, type ColumnState, type Compareable, type ControllerEventMap, type DisplayColumnOptions, type ExportOptions, type FilterCallback, type Filters, InputEditor, type InputEditorOptions, type InputType, type InternalColumnOptions, type MaybePromise, type NestedKeyOf, NumberEditor, type NumberEditorOptions, type QueryToken, type Renderable, type RestorableColumnState, type RestorableTableState, type RowId, type RowIdCallback, type RowPartsCallback, type RowSelectionMethod, SelectEditor, type SelectEditorOptions, type SortOrder, type SortState, type SortValueCallback, type StorageInterface, type StorageOptions, type TableControllerOptions, type TableState, TextEditor, type TextEditorOptions, type TokenizerCallback, TypedEventTarget, type UnspecifiedRecord, type ValueFormatterCallback, YatlCellEditEvent, YatlColumnReorderEvent, YatlColumnReorderRequest, YatlColumnResizeEvent, YatlColumnSortEvent, YatlColumnSortRequest, YatlColumnToggleEvent, YatlEvent, YatlRowClickEvent, YatlRowSelectEvent, YatlRowSelectRequest, YatlTable, type YatlTableApi, YatlTableController, type YatlTableControllerApi, YatlTableControllerEvent, YatlTableSearchEvent, YatlTableStateChangeEvent, YatlTableViewChangeEvent, createRegexTokenizer, createState, findColumn, getColumnStateChanges, getNestedValue, isDisplayColumn, isInternalColumn, isRowIdType, isRowSelectionMethod, setNestedValue, whitespaceTokenizer };