@timlassiter11/yatl 1.0.18 → 1.2.0

package/dist/index.d.mts

@@ -1,63 +1,6 @@
-import * as lit_html from 'lit-html';
 import * as lit from 'lit';
-import { LitElement, TemplateResult, ReactiveController, ReactiveControllerHost, nothing } from 'lit';
-export { html, noChange, nothing, svg } from 'lit';
+import { TemplateResult, ReactiveController, ReactiveControllerHost, LitElement, nothing } from 'lit';
 import { DirectiveResult } from 'lit/directive.js';
-export { unsafeHTML } from 'lit/directives/unsafe-html.js';
-
-declare class YatlButton extends LitElement {
-    static styles: lit.CSSResult[];
-    disabled: boolean;
-    type: 'button' | 'submit' | 'reset';
-    render(): lit_html.TemplateResult<1>;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'yatl-button': YatlButton;
-    }
-}
-
-declare class YatlButtonGroup extends LitElement {
-    static styles: lit.CSSResult[];
-    render(): lit_html.TemplateResult<1>;
-    private getFlattenedElements;
-    private handleSlotChange;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'yatl-button-group': YatlButtonGroup;
-    }
-}
-
-declare class YatlDropdown extends LitElement {
-    static styles: lit.CSSResult[];
-    private detailsElement;
-    open: boolean;
-    protected render(): lit_html.TemplateResult<1>;
-    private handleDropdownTriggerClick;
-    private handleDocumentClick;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'yatl-dropdown': YatlDropdown;
-    }
-}
-
-/**
- * @fires yatl-dropdown-toggle - Fired when a dropdown item's checked state changes
- */
-declare class YatlDropdownItem extends LitElement {
-    static styles: lit.CSSResult[];
-    value: string;
-    checked: boolean;
-    protected render(): lit_html.TemplateResult<1>;
-    private handleCheckboxChanged;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'yatl-dropdown-item': YatlDropdownItem;
-    }
-}
 
 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
@@ -67,6 +10,9 @@ type NestedKeyOf<ObjectType> = ObjectType extends object ? {
  * Default type for the table.
  */
 type UnspecifiedRecord = Record<string, any>;
+/**
+ * Valid types for Row IDs
+ */
 type RowId = string | number;
 /**
  * Known compareable type
@@ -229,7 +175,7 @@ interface InternalColumnOptions<T> extends BaseColumnOptions<T> {
      * Marks this column as internal-only.
      * It will be indexed for search and filtering, but strictly excluded from the UI.
      */
-    display: 'internal';
+    role: 'internal';
 }
 type ColumnOptions<T> = DisplayColumnOptions<T> | InternalColumnOptions<T>;
 /**
@@ -289,6 +235,10 @@ type RowSelectionMethod = 'single' | 'multi';
  * @returns the part string or list of part strings that should be added to this row.
  */
 type RowPartsCallback<T> = (row: T) => string | string[];
+/**
+ * Options used to configure what state information
+ * should be saved and restored automatically.
+ */
 interface StorageOptions {
     /**
      * The unique key used to store the table state in the browser.
@@ -334,11 +284,20 @@ interface TableState<T> {
 type RestorableTableState<T> = Partial<Omit<TableState<T>, 'columns'>> & {
     columns?: RestorableColumnState<T>[];
 };
+/**
+ * Options for configuring what date should be exported.
+ */
 interface ExportOptions {
+    /** Include all rows including filtered out rows */
     includeAllRows?: boolean;
+    /** Include columns that have been hidden */
     includeHiddenColumns?: boolean;
+    /** Include columns marked as internal */
     includeInternalColumns?: boolean;
 }
+/**
+ * Options for configuring a table controller
+ */
 interface TableControllerOptions<T extends object> {
     enableSearchTokenization?: boolean;
     enableSearchScoring?: boolean;
@@ -353,8 +312,9 @@ interface TableControllerOptions<T extends object> {
 /**
  * Base event class that bubbles and is composed.
  */
-declare class YatlEvent extends Event {
+declare abstract class YatlEvent extends Event {
     constructor(name: string, options?: EventInit);
+    abstract clone(): YatlEvent;
 }
 declare class YatlRowClickEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
     readonly row: T;
@@ -364,26 +324,30 @@ 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 YatlRowSelectRequestEvent extends YatlEvent {
+declare class YatlRowSelectRequest extends YatlEvent {
     readonly rowId: RowId;
     readonly selected: boolean;
     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 {
     readonly selectedIds: RowId[];
     readonly previouslySelectedRows: RowId[];
     static readonly EVENT_NAME = "yatl-row-select";
     constructor(selectedIds: RowId[], previouslySelectedRows: RowId[]);
+    clone(): YatlRowSelectEvent;
 }
-declare class YatlColumnSortRequestEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlColumnSortRequest<T extends object = UnspecifiedRecord> extends YatlEvent {
     readonly field: NestedKeyOf<T>;
     readonly order: SortOrder | null;
     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 {
     readonly field: NestedKeyOf<T>;
@@ -391,96 +355,88 @@ declare class YatlColumnSortEvent<T extends object = UnspecifiedRecord> extends
     readonly multisort: boolean;
     static readonly EVENT_NAME = "yatl-column-sort";
     constructor(field: NestedKeyOf<T>, order: SortOrder | null, multisort: boolean);
+    clone(): YatlColumnSortEvent<T>;
 }
-declare class YatlColumnToggleRequestEvent extends YatlEvent {
-    readonly field: string;
+declare class YatlColumnToggleRequest<T extends object = UnspecifiedRecord> extends YatlEvent {
+    readonly field: NestedKeyOf<T>;
     readonly visibility: boolean;
     static readonly EVENT_NAME = "yatl-column-toggle-request";
-    constructor(field: string, visibility: boolean);
+    constructor(field: NestedKeyOf<T>, visibility: boolean);
+    clone(): YatlColumnToggleRequest<T>;
 }
 declare class YatlColumnToggleEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
     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 {
     readonly field: NestedKeyOf<T>;
     readonly width: number | null;
     static readonly EVENT_NAME = "yatl-column-resize";
     constructor(field: NestedKeyOf<T>, width: number | null);
+    clone(): YatlColumnResizeEvent<T>;
 }
-declare class YatlColumnReorderRequestEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
+declare class YatlColumnReorderRequest<T extends object = UnspecifiedRecord> extends YatlEvent {
     readonly movedColumn: NestedKeyOf<T>;
     readonly originalIndex: number;
     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 {
     readonly order: NestedKeyOf<T>[];
     static readonly EVENT_NAME = "yatl-column-reorder";
     constructor(order: NestedKeyOf<T>[]);
+    clone(): YatlColumnReorderEvent<T>;
 }
 declare class YatlTableSearchEvent extends YatlEvent {
     readonly query: string;
     static readonly EVENT_NAME = "yatl-table-search";
     constructor(query: string);
+    clone(): YatlTableSearchEvent;
 }
 declare class YatlTableViewChangeEvent<T extends object = UnspecifiedRecord> extends YatlEvent {
     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 {
     readonly state: TableState<T>;
     readonly triggers: string[];
     static readonly EVENT_NAME = "yatl-table-state-change";
     constructor(state: TableState<T>, triggers: string[]);
-}
-declare class YatlDropdownToggleEvent extends YatlEvent {
-    readonly value: string;
-    readonly checked: boolean;
-    static readonly EVENT_NAME = "yatl-dropdown-toggle";
-    constructor(value: string, checked: boolean);
-}
-declare class YatlToolbarSearchInput extends YatlEvent {
-    readonly value: string;
-    static readonly EVENT_NAME = "yatl-toolbar-search-input";
-    constructor(value: string);
-}
-declare class YatlToolbarSearchChange extends YatlEvent {
-    readonly value: string;
-    static readonly EVENT_NAME = "yatl-toolbar-search-change";
-    constructor(value: string);
-}
-declare class YatlToolbarExportClick extends YatlEvent {
-    static readonly EVENT_NAME = "yatl-toolbar-export-click";
-    constructor();
+    clone(): YatlTableStateChangeEvent<T>;
 }
 declare global {
     interface HTMLElementEventMap {
         [YatlRowClickEvent.EVENT_NAME]: YatlRowClickEvent;
-        [YatlRowSelectRequestEvent.EVENT_NAME]: YatlRowSelectRequestEvent;
+        [YatlRowSelectRequest.EVENT_NAME]: YatlRowSelectRequest;
         [YatlRowSelectEvent.EVENT_NAME]: YatlRowSelectEvent;
-        [YatlColumnSortRequestEvent.EVENT_NAME]: YatlColumnSortRequestEvent;
+        [YatlColumnSortRequest.EVENT_NAME]: YatlColumnSortRequest;
         [YatlColumnSortEvent.EVENT_NAME]: YatlColumnSortEvent;
-        [YatlColumnToggleRequestEvent.EVENT_NAME]: YatlColumnToggleRequestEvent;
+        [YatlColumnToggleRequest.EVENT_NAME]: YatlColumnToggleRequest;
         [YatlColumnToggleEvent.EVENT_NAME]: YatlColumnToggleEvent;
         [YatlColumnResizeEvent.EVENT_NAME]: YatlColumnResizeEvent;
-        [YatlColumnReorderRequestEvent.EVENT_NAME]: YatlColumnReorderRequestEvent;
+        [YatlColumnReorderRequest.EVENT_NAME]: YatlColumnReorderRequest;
         [YatlColumnReorderEvent.EVENT_NAME]: YatlColumnReorderEvent;
         [YatlTableSearchEvent.EVENT_NAME]: YatlTableSearchEvent;
         [YatlTableViewChangeEvent.EVENT_NAME]: YatlTableViewChangeEvent;
         [YatlTableStateChangeEvent.EVENT_NAME]: YatlTableStateChangeEvent;
-        [YatlDropdownToggleEvent.EVENT_NAME]: YatlDropdownToggleEvent;
-        [YatlToolbarSearchInput.EVENT_NAME]: YatlToolbarSearchInput;
-        [YatlToolbarSearchChange.EVENT_NAME]: YatlToolbarSearchChange;
-        [YatlToolbarExportClick.EVENT_NAME]: YatlToolbarExportClick;
     }
 }
 
-declare class YatlTableController<T extends object = UnspecifiedRecord> implements ReactiveController {
+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 {
     private hosts;
     private _enableSearchTokenization;
     private _enableSearchScoring;
@@ -493,6 +449,7 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> implemen
     private _rowIdCallback;
     private _data;
     private _filteredData;
+    private _dataUpdateTimestamp;
     private _searchQuery;
     private _searchTokenizer;
     private _filters;
@@ -607,6 +564,7 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> implemen
     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;
@@ -624,6 +582,7 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> implemen
     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.
@@ -679,8 +638,7 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> implemen
     deselectAll(): void;
     /**
      * Export the current visible table data to a CSV file.
-     * @param filename - The name of the file to save.
-     * @param all - If `true`, exports all original data (ignoring filters). If `false` (default), exports only the currently visible (filtered and sorted) rows.
+     * @param options - Options for configuring what should be exported.
      */
     export(options?: ExportOptions): Blob;
     /**
@@ -728,18 +686,17 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> implemen
     updateRowAtIndex(index: number, data: Partial<T>): void;
     /**
      * Deletes the row with the matching ID.
-     * @param id - The ID of the row to delete
+     * @param rowIds - The IDs rows to delete
      */
     deleteRow(...rowIds: RowId[]): void;
     /**
      * Deletes a row at a specific original index from the table.
-     * @param index - The original index of the row to delete.
+     * @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;
-    private dispatchEvent;
     hostConnected(): void;
     hostDisconnected(): void;
     hostUpdate(): void;
@@ -773,6 +730,16 @@ declare class YatlTableController<T extends object = UnspecifiedRecord> implemen
     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.
@@ -798,12 +765,13 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
     static styles: lit.CSSResult[];
     private tableElement;
     private virtualizer?;
-    private dataLastUpdate;
     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.
@@ -975,6 +943,7 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
     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;
     /**
@@ -1043,7 +1012,7 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
     /**
      * Export the current visible table data to a CSV file.
      * @param filename - The name of the file to save.
-     * @param all - If `true`, exports all original data (ignoring filters). If `false` (default), exports only the currently visible (filtered and sorted) rows.
+     * @param options - Options for configuring what should be exported.
      */
     export(filename: string, options?: ExportOptions): void;
     scrollToRow(row: T): Promise<void>;
@@ -1099,7 +1068,7 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
     updateRowAtIndex(index: number, data: Partial<T>): void;
     /**
      * Deletes the row with the matching ID.
-     * @param id - The ID of the row to delete
+     * @param rowIds - The IDs rows to delete
      */
     deleteRow(...rowIds: RowId[]): void;
     /**
@@ -1115,6 +1084,7 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
     protected renderHeader(): TemplateResult<1>;
     protected renderCellContents(value: unknown, column: DisplayColumnOptions<T>, row: T): {} | null | undefined;
     protected renderCell(column: DisplayColumnOptions<T>, row: T): TemplateResult<1>;
+    protected renderCheckbox(row: T, selected: boolean): TemplateResult<1>;
     protected renderRowSelectorCell(row: T, selected: boolean): TemplateResult<1>;
     protected renderRowNumberCell(rowNumber: number): TemplateResult<1>;
     protected renderRow(row: T, renderIndex: number): TemplateResult<1>;
@@ -1122,7 +1092,12 @@ declare class YatlTable<T extends object = UnspecifiedRecord> extends LitElement
     protected renderFooter(): TemplateResult<1> | typeof nothing;
     protected render(): TemplateResult<1>;
     private renderCellWrapper;
+    connectedCallback(): void;
     disconnectedCallback(): void;
+    private readonly eventNames;
+    private addControllerListeners;
+    private removeControllerListeners;
+    private redispatchControllerEvent;
     private hasVisibleColumn;
     /**
      * Gets the width of each column in the
@@ -1148,76 +1123,32 @@ declare global {
     }
 }
 
-/**
- * A "Batteries Included" wrapper for `<yatl-table>` that provides a built-in toolbar.
- *
- * This element extends the core table engine to automatically render UI controls
- * for common user actions, such as toggling column visibility and exporting data.
- *
- * It inherits all properties and events from `<yatl-table>`.
- *
- * @element yatl-table-ui
- *
- * @slot toolbar - Adds contents to the right of the toolbar button group
- * @slot toolbar-button-group - Adds content into the toolbar button group.
- * @slot footer - Inherited from `yatl-table`. Content to display in the table footer area.
- * @slot body - Inherited from `yatl-table`. Custom rendering for the table body.
- */
-declare class YatlTableUi<T extends object = UnspecifiedRecord> extends YatlTable<T> {
-    static styles: lit.CSSResult[];
-    /**
-     * Toggles the visibility of the column picker button in the toolbar. Defaults to `true`.
-     */
-    showColumnPicker: boolean;
-    /**
-     * Toggles the visibility of the CSV export button in the toolbar. Defaults to `true`.
-     */
-    showExportButton: boolean;
-    protected render(): lit_html.TemplateResult<1>;
-    private handleTableExportClicked;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'yatl-table-ui': YatlTableUi;
-    }
-}
+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 isRowIdType(value: unknown): value is RowId;
+declare function isRowSelectionMethod(value: string | null): value is RowSelectionMethod;
 /**
- * A table toolbar component with a search input, column picker, and export button.
- *
- * @element yatl-toolbar
- * @summary Provides a cohesive set of controls for searching, exporting, and managing column visibility,
- * along with a flexible slot for custom actions.
- *
- * @slot - Adds contents to the right of the toolbar button group
- * @slot toolbar-button-group - Adds content into the toolbar button group.
- *
- * @fires yatl-toolbar-search-input - Fired synchronously as the user types in the search box. Useful for real-time highlighting or suggestions.
- * @fires yatl-toolbar-search-change - Fired when the user commits a search query (e.g., on 'Enter' or blur). Use this for triggering the actual table filter.
- * @fires yatl-toolbar-export-click - Fired when the export button is clicked. Payload indicates the requested format.
- * @fires yatl-column-toggle-request - Fired when a column's visibility is toggled in the dropdown. The consumer must handle this by updating the table state.
- *
+ * Get a value from an object based on a path.
+ * @param obj - The object to get the value from
+ * @param path - The path of the value
+ * @returns The value found at the given path
  */
-declare class YatlToolbar<T extends object = UnspecifiedRecord> extends LitElement {
-    static styles: lit.CSSResult[];
-    private _controller?;
-    get controller(): YatlTableController<T> | undefined;
-    set controller(controller: YatlTableController<T> | undefined);
-    showColumnPicker: boolean;
-    showExportButton: boolean;
-    protected render(): lit_html.TemplateResult<1>;
-    protected renderColumnPicker(): lit_html.TemplateResult<1>;
-    protected renderColumnVisibilityToggle(column: DisplayColumnOptions<T>): lit_html.TemplateResult<1>;
-    private handleDropdownToggle;
-    protected renderExportButton(): lit_html.TemplateResult<1>;
-    private onSearchInput;
-    private onSearchChange;
-    private onExportClick;
-}
-declare global {
-    interface HTMLElementTagNameMap {
-        'yatl-toolbar': YatlToolbar;
-    }
-}
+declare function getNestedValue(obj: object, path: string): unknown;
+declare function setNestedValue(obj: object, path: string, value: unknown): void;
+
+declare const createRegexTokenizer: (exp?: string) => (value: string) => {
+    value: string;
+    quoted: boolean;
+}[];
+declare const whitespaceTokenizer: (value: string) => {
+    value: string;
+    quoted: boolean;
+}[];
 
-export { type BaseColumnOptions, type CellPartsCallback, type CellRenderCallback, type ColumnFilterCallback, type ColumnOptions, type ColumnRole, type ColumnState, type Compareable, 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, type UnspecifiedRecord, type ValueFormatterCallback, YatlButton, YatlButtonGroup, YatlColumnReorderEvent, YatlColumnReorderRequestEvent, YatlColumnResizeEvent, YatlColumnSortEvent, YatlColumnSortRequestEvent, YatlColumnToggleEvent, YatlColumnToggleRequestEvent, YatlDropdown, YatlDropdownItem, YatlDropdownToggleEvent, YatlEvent, YatlRowClickEvent, YatlRowSelectEvent, YatlRowSelectRequestEvent, YatlTable, YatlTableController, YatlTableSearchEvent, YatlTableStateChangeEvent, YatlTableUi, YatlTableViewChangeEvent, YatlToolbar, YatlToolbarExportClick, YatlToolbarSearchChange, YatlToolbarSearchInput };
+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, YatlColumnToggleRequest, YatlEvent, YatlRowClickEvent, YatlRowSelectEvent, YatlRowSelectRequest, YatlTable, YatlTableController, YatlTableSearchEvent, YatlTableStateChangeEvent, YatlTableViewChangeEvent, createRegexTokenizer, createState, findColumn, getColumnStateChanges, getNestedValue, isDisplayColumn, isInternalColumn, isRowIdType, isRowSelectionMethod, setNestedValue, whitespaceTokenizer };