@guiexpert/table 1.1.90 → 1.1.91

package/lib/common/debounce.d.ts

@@ -1 +1,2 @@
+/** @category Utilities */
 export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number): (...args: Parameters<T>) => void;

package/lib/common/decorator/avoid-double-execution.decorator.d.ts

@@ -3,5 +3,7 @@
  *
  * @param {number} [delay=500] - The delay threshold in milliseconds.
  * @returns {Function} - The decorated method descriptor.
+ *
+ * @category Utilities
  */
 export declare function AvoidDoubleExecution(delay?: number): (_target: any, _key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/lib/common/escape-html.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Escapes a value for HTML text and for (double or single quoted) HTML attribute values:
+ * `&`, `<`, `>`, `"` and `'` become entities; `null` and `undefined` become an empty string.
+ *
+ * Use it whenever data (cell values, labels, ids from the server …) is written into `innerHTML` – otherwise a value
+ * like `<img src=x onerror=alert(1)>` is executed as markup (HTML injection / XSS), and a `"` cuts an attribute value.
+ *
+ * @param {unknown} value - any value; it is converted with `String(value)`
+ * @returns {string} the escaped text
+ *
+ * @example
+ * // in a cell renderer
+ * const cellDiv = document.createElement('div');
+ * const cellValue = 'Tom & Jerry <3';
+ * cellDiv.innerHTML = `<div class="my-label" title="${escapeHtml(cellValue)}">${escapeHtml(cellValue)}</div>`;
+ *
+ * @example
+ * escapeHtml('<b>"Tom" & Jerry</b>'); // "&lt;b&gt;&quot;Tom&quot; &amp; Jerry&lt;/b&gt;"
+ *
+ * @category Utilities
+ */
+export declare function escapeHtml(value: unknown): string;

package/lib/common/generator/column-def-generator-service.d.ts

@@ -1,5 +1,6 @@
-import { PropertyType } from './domain/property-type';
+import { PropertyType } from './domain/property-type.js';
 
+/** @category Utilities */
 export declare class ColumnDefGenerator {
     rootPropertyType: PropertyType | null;
     private allowCustomRenderer;

package/lib/common/generator/domain/property-type.d.ts

@@ -1,58 +1,77 @@
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_ANY = "any";
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_UNDEFINED = "undefined";
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_NULL = "null";
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_STRING = "string";
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_NUMBER = "number";
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_BOOLEAN = "boolean";
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_ARRAY = "Array";
+/** @category Utilities */
 export declare const PROPERTY_TYPE_KEY_OBJECT = "object";
+/** @category Utilities */
 export declare const UNIMPORTANT_TYPES: string[];
+/** @category Utilities */
 export interface PropertyType {
     type: string;
     propertyName: string;
 }
+/** @category Utilities */
 export declare class AnyPropertyType implements PropertyType {
     propertyName: string;
     type: string;
     constructor(propertyName: string);
 }
+/** @category Utilities */
 export declare class UndefinedPropertyType implements PropertyType {
     propertyName: string;
     type: string;
     constructor(propertyName: string);
 }
+/** @category Utilities */
 export declare class NullPropertyType implements PropertyType {
     propertyName: string;
     type: string;
     constructor(propertyName: string);
 }
+/** @category Utilities */
 export declare class StringPropertyType implements PropertyType {
     propertyName: string;
     type: string;
     constructor(propertyName: string);
 }
+/** @category Utilities */
 export declare class NumberPropertyType implements PropertyType {
     propertyName: string;
     type: string;
     constructor(propertyName: string);
 }
+/** @category Utilities */
 export declare class BooleanPropertyType implements PropertyType {
     propertyName: string;
     type: string;
     constructor(propertyName: string);
 }
+/** @category Utilities */
 export declare class ArrayPropertyType implements PropertyType {
     propertyName: string;
     items: PropertyType[];
     type: string;
     constructor(propertyName: string, items?: PropertyType[]);
 }
+/** @category Utilities */
 export declare class PropertyItem {
     propertyName: string;
     types: PropertyType[];
     constructor(propertyName: string, types?: PropertyType[]);
     toString(): string;
 }
+/** @category Utilities */
 export declare class ObjectPropertyType implements PropertyType {
     propertyName: string;
     className: string;

package/lib/common/generator/domain/value-info.d.ts

@@ -1,5 +1,6 @@
-import { PropertyItem } from './property-type';
+import { PropertyItem } from './property-type.js';
 
+/** @category Utilities */
 export declare class ValueInfo {
     property: string;
     value: any;

package/lib/common/generator/json-service.d.ts

@@ -1,3 +1,4 @@
+/** @category Utilities */
 export declare class JsonService {
     /**
      *

package/lib/common/generator/property-type.service.d.ts

@@ -1,6 +1,7 @@
-import { PropertyType } from './domain/property-type';
-import { ValueInfo } from './domain/value-info';
+import { PropertyType } from './domain/property-type.js';
+import { ValueInfo } from './domain/value-info.js';
 
+/** @category Utilities */
 export declare class PropertyTypeService {
     debugging: boolean;
     /**

package/lib/common/generator/scheme-generator-service.d.ts

@@ -1,4 +1,4 @@
-import { PropertyType } from './domain/property-type';
+import { PropertyType } from './domain/property-type.js';
 
 /**
  *
@@ -63,6 +63,8 @@ import { PropertyType } from './domain/property-type';
  * const rootPropertyType: PropertyType = new PropertyTypeService().object2PropertyType(demoData, 'XyzRows');
  * console.log(new SchemeGenerator().renderTypeScriptInterfaces(rootPropertyType).join('\n'));
  *
+ *
+ * @category Utilities
  */
 export declare class SchemeGenerator {
     orOperator: string;

package/lib/common/generator/string-util.d.ts

@@ -1,9 +1,12 @@
+/** @category Utilities */
 export declare const entitySuffix = "Entity";
 /**
  * Generates an entity name by formatting the input name and appending a predefined suffix if necessary.
  *
  * @param {string} name - The base name to generate the entity name from.
  * @return {string} The formatted entity name with the appropriate suffix.
+ *
+ * @category Utilities
  */
 export declare function getEntityName(name: string): string;
 /**
@@ -11,6 +14,8 @@ export declare function getEntityName(name: string): string;
  *
  * @param {string} text - The input string to process and trim suffixes from.
  * @return {string} The modified string with the suffix removed, or the original string if no suffix was found.
+ *
+ * @category Utilities
  */
 export declare function trimArraySuffixes(text: string): string;
 /**
@@ -18,5 +23,7 @@ export declare function trimArraySuffixes(text: string): string;
  *
  * @param {string} text - The input string to be processed.
  * @return {string} The transformed string with the first letter in uppercase. Returns an empty string if the input is invalid or empty.
+ *
+ * @category Utilities
  */
 export declare function firstLetterUppercase(text: string): string;

package/lib/common/throttle.d.ts

@@ -1 +1,2 @@
+/** @category Utilities */
 export declare function throttle<T extends (...args: any[]) => any>(func: T, wait?: number): (...args: Parameters<T>) => void;

package/lib/table/action/action-id.type.d.ts

@@ -2,13 +2,17 @@
  * An array of action identifiers.
  *
  * @type {ReadonlyArray<string>}
+ *
+ * @category Keyboard
  */
-export declare const actionIds: readonly ["COPY_2_CLIPBOARD", "START_EDITING", "TOGGLE_SELECTION", "SELECT_ALL", "DESELECT_ALL", "NAVIGATE_LEFT", "NAVIGATE_RIGHT", "NAVIGATE_UP", "NAVIGATE_DOWN"];
+export declare const actionIds: readonly ["COPY_2_CLIPBOARD", "START_EDITING", "TOGGLE_SELECTION", "SELECT_ALL", "DESELECT_ALL", "NAVIGATE_LEFT", "NAVIGATE_RIGHT", "NAVIGATE_UP", "NAVIGATE_DOWN", "NAVIGATE_ROW_START", "NAVIGATE_ROW_END", "NAVIGATE_FIRST_CELL", "NAVIGATE_LAST_CELL", "NAVIGATE_PAGE_UP", "NAVIGATE_PAGE_DOWN", "ACTIVATE_CELL"];
 /**
  * Represents an action ID.
  *
  * @typedef {string} ActionId
  * @memberof module:myModule
  * @see module:myModule.actionIds
+ *
+ * @category Keyboard
  */
 export type ActionId = typeof actionIds[number];

package/lib/table/action/on-action-triggered.if.d.ts

@@ -1,5 +1,6 @@
-import { ActionId } from './action-id.type';
+import { ActionId } from './action-id.type.js';
 
+/** @category Keyboard */
 export interface OnActionTriggeredIf {
     /**
      * Triggers an action based on the provided action ID.

package/lib/table/action/osx-shortcut-actionId-mapping.d.ts

@@ -1,4 +1,4 @@
-import { ActionId } from './action-id.type';
+import { ActionId } from './action-id.type.js';
 
 /**
  * Class representing the mapping of OS X shortcut actions to action IDs.
@@ -6,6 +6,8 @@ import { ActionId } from './action-id.type';
  * Use 'meta' for the MacOS 'cmd' key.
  *
  * @class OsxShortcutActionIdMapping
+ *
+ * @category Keyboard
  */
 export declare class OsxShortcutActionIdMapping {
     get(): {

package/lib/table/action/shortcut-actionid-mapping.type.d.ts

@@ -1,8 +1,10 @@
-import { ActionId } from './action-id.type';
+import { ActionId } from './action-id.type.js';
 
 /**
  * Represents a mapping of shortcut action IDs.
  * @typedef {Object.<string, ActionId>} ShortcutActionIdMapping
+ *
+ * @category Keyboard
  */
 export type ShortcutActionIdMapping = {
     [key: string]: ActionId;

package/lib/table/action/shortcut-util.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Normalizes a shortcut string (e.g. a key of a {@link ShortcutActionIdMapping}) so that it can be compared with
+ * {@link createHarmonizedShortcutByKeyboardEvent}: "+" becomes a space, symbols and synonyms are unified
+ * ("⌘"/"meta"/"command" → "cmd", "arrowup" → "up" …), modifiers come first.
+ *
+ * @example
+ * harmonizeShortcut('meta+c');    // "cmd c"
+ * harmonizeShortcut('arrowup');   // "up"
+ *
+ * @category Keyboard
+ */
 export declare function harmonizeShortcut(shortcut: string): string;
+/** @category Keyboard */
 export declare function createHarmonizedShortcutByKeyboardEvent(keyboardEvent: KeyboardEvent): string;

package/lib/table/action/shortcut.service.d.ts

@@ -1,9 +1,11 @@
-import { TableScope } from '../table-scope';
-import { ShortcutActionIdMapping } from './shortcut-actionid-mapping.type';
-import { OnActionTriggeredIf } from './on-action-triggered.if';
+import { TableScope } from '../table-scope.js';
+import { ShortcutActionIdMapping } from './shortcut-actionid-mapping.type.js';
+import { OnActionTriggeredIf } from './on-action-triggered.if.js';
 
 /**
  * Represents a service for managing shortcuts and triggering actions based on keyboard events.
+ *
+ * @category Keyboard
  */
 export declare class ShortcutService {
     protected tableScope: TableScope;

package/lib/table/action/windows-shortcut-actionId-mapping.d.ts

@@ -1,9 +1,11 @@
-import { ActionId } from './action-id.type';
+import { ActionId } from './action-id.type.js';
 
 /**
  * Class representing a mapping of Windows shortcut keys to action IDs.
  *
  * Use 'meta' for the MacOS 'cmd' key.
+ *
+ * @category Keyboard
  */
 export declare class WindowsShortcutActionIdMapping {
     get(): {

package/lib/table/aria/aria-grid-info.d.ts

@@ -0,0 +1,76 @@
+import { TableModelIf } from '../data/tablemodel/table-model.if.js';
+import { AreaIdent } from '../data/tablemodel/area-ident.type.js';
+
+/**
+ * Row and column numbers for screen readers – computed once per render pass from the table model.
+ *
+ * With virtual scrolling only the visible rows and columns are in the DOM, so the table tells screen readers the
+ * real size (`aria-rowcount`, `aria-colcount` on the grid) and the position of every rendered row and cell
+ * (`aria-rowindex`, `aria-colindex`):
+ *
+ * - rows are numbered 1-based over header → body → footer; a hidden header/footer (`setHeaderVisible(false)`) counts 0,
+ * - the body counts **all** rows of the model (after the filter; a tree: the displayed nodes),
+ * - columns count only the **shown** columns (width > 0): a column hidden with `setColumnVisible(…, false)` has no
+ *   `aria-colindex`, the following columns move up,
+ * - a body with an unknown row count (`getRowCount() < 0`) gives `aria-rowcount="-1"`.
+ *
+ * @example
+ * // 1 header row, 1000 body rows, 10 columns, column 3 hidden
+ * const info = AriaGridInfo.create(tableModel);
+ * info.rowCount;               // 1001
+ * info.colCount;               // 9
+ * info.rowIndex("header", 0);  // 1
+ * info.rowIndex("body", 0);    // 2
+ * info.colIndex(4);            // 4 (column 3 is skipped)
+ * info.colIndex(3);            // 0 (hidden)
+ *
+ * @since 1.1.91
+ * @category Accessibility
+ */
+export declare class AriaGridInfo {
+    readonly headerRowCount: number;
+    readonly bodyRowCount: number;
+    readonly footerRowCount: number;
+    private readonly colIndexMap;
+    /**
+     * @param {number} headerRowCount - rendered header rows (0 if the header is hidden)
+     * @param {number} bodyRowCount - body rows of the model (negative = unknown)
+     * @param {number} footerRowCount - rendered footer rows (0 if the footer is hidden)
+     * @param {number[]} colIndexMap - per model column its `aria-colindex` (0 = hidden)
+     */
+    constructor(headerRowCount: number, bodyRowCount: number, footerRowCount: number, colIndexMap: number[]);
+    /**
+     * Reads the counts of a table model.
+     *
+     * @param {TableModelIf} tableModel - the table model (only the area models, header/footer visibility and column widths are read)
+     * @returns {AriaGridInfo} the counts
+     */
+    static create(tableModel: Pick<TableModelIf, "getAreaModel" | "isHeaderVisibe" | "isFooterVisibe" | "getColumnCount" | "getColumnWidth">): AriaGridInfo;
+    /** `aria-rowcount` of the grid: header + body + footer rows, `-1` if the body does not know its row count. */
+    get rowCount(): number;
+    /** `aria-colcount` of the grid: the number of shown columns. */
+    get colCount(): number;
+    /**
+     * `aria-rowindex` of a row (1-based over header → body → footer).
+     *
+     * @param {AreaIdent} area - header, body or footer
+     * @param {number} rowIndex - row index in the area
+     * @returns {number} the 1-based row number in the whole grid
+     */
+    rowIndex(area: AreaIdent, rowIndex: number): number;
+    /**
+     * `aria-colindex` of a column.
+     *
+     * @param {number} columnIndex - model column index (west + center + east)
+     * @returns {number} the 1-based position among the shown columns, 0 for a hidden or unknown column
+     */
+    colIndex(columnIndex: number): number;
+    /**
+     * `aria-colspan` of a cell that spans columns: the number of **shown** columns it covers.
+     *
+     * @param {number} columnIndex - the first column of the cell
+     * @param {number} colspan - the number of model columns the cell spans
+     * @returns {number} the number of shown columns (at least 1)
+     */
+    colSpan(columnIndex: number, colspan: number): number;
+}

package/lib/table/aria/aria-ids.d.ts

@@ -0,0 +1,56 @@
+import { AreaIdent } from '../data/tablemodel/area-ident.type.js';
+import { SideIdent } from '../data/side-ident.type.js';
+
+/**
+ * Builds the element IDs the table needs for ARIA references (`aria-activedescendant`, `aria-owns`).
+ *
+ * All IDs of one table start with the same prefix: `ge-` + the `id` of the host element, or `ge-t<n>`
+ * (a running number) if the host has no id. Several tables on one page therefore never clash, and with a host id
+ * the IDs stay the same when the table is rebuilt.
+ *
+ * Only the focused cell carries an ID (see {@link cell}); the other cells have none (performance).
+ *
+ * @example
+ * const ids = new AriaIds(AriaIds.createPrefix("orders"));
+ * ids.cell("body", 5, 2);           // "ge-orders-body-r5-c2"
+ * ids.rowGroup("header", "center"); // "ge-orders-rg-header-center"
+ * ids.liveRegion();                 // "ge-orders-live"
+ *
+ * @since 1.1.91
+ * @category Accessibility
+ */
+export declare class AriaIds {
+    readonly prefix: string;
+    private static counter;
+    constructor(prefix: string);
+    /**
+     * The ID prefix of a table.
+     *
+     * @param {string} [hostId] - the `id` of the host element (may be empty)
+     * @returns {string} `"ge-" + hostId`, or `"ge-t" + n` with a number that is unique on the page
+     */
+    static createPrefix(hostId?: string): string;
+    /**
+     * The ID of a cell (set on the focused cell, referenced by `aria-activedescendant`).
+     *
+     * @param {AreaIdent} area - header, body or footer
+     * @param {number} rowIndex - row index in the area
+     * @param {number} columnIndex - model column index (west + center + east)
+     * @returns {string} e.g. `"ge-t1-body-r5-c2"`
+     */
+    cell(area: AreaIdent, rowIndex: number, columnIndex: number): string;
+    /**
+     * The ID of one of the nine row groups (`role="rowgroup"`), referenced by `aria-owns` of the host.
+     *
+     * @param {AreaIdent} area - header, body or footer
+     * @param {SideIdent} side - west, center or east
+     * @returns {string} e.g. `"ge-t1-rg-body-center"`
+     */
+    rowGroup(area: AreaIdent, side: SideIdent): string;
+    /**
+     * The ID of the live region (the element that speaks announcements, see {@link LiveAnnouncer}).
+     *
+     * @returns {string} e.g. `"ge-t1-live"`
+     */
+    liveRegion(): string;
+}

package/lib/table/aria/aria-texts.d.ts

@@ -0,0 +1,34 @@
+import { AriaTextsIf } from './aria-texts.if.js';
+import { SortState } from '../data/common/sort-state.type.js';
+
+/**
+ * The English default texts for screen readers (see {@link AriaTextsIf}).
+ *
+ * The table uses `AriaTexts.create(tableOptions.ariaTexts)`: your functions replace the defaults one by one.
+ *
+ * @example
+ * const texts = AriaTexts.create({ copied: (n: number) => `${n} Zellen kopiert` });
+ * texts.copied(3);       // "3 Zellen kopiert"
+ * texts.filtered(42);    // "42 rows" (default)
+ *
+ * @since 1.1.91
+ * @category Accessibility
+ */
+export declare class AriaTexts implements AriaTextsIf {
+    /**
+     * The default texts, overridden by the given functions.
+     *
+     * @param {Partial<AriaTextsIf>} [overrides] - functions that replace the English defaults (e.g. `tableOptions.ariaTexts`)
+     * @returns {AriaTextsIf} a complete set of texts
+     */
+    static create(overrides?: Partial<AriaTextsIf>): AriaTextsIf;
+    sorted(columnLabel: string, sortState: SortState): string;
+    filtered(rowCount: number): string;
+    copied(cellCount: number): string;
+    allSelected(): string;
+    selectionCleared(): string;
+    selectRow(rowNumber: number): string;
+    selectAllRows(): string;
+    expandGroup(groupLabel: string): string;
+    collapseGroup(groupLabel: string): string;
+}

package/lib/table/aria/aria-texts.if.d.ts

@@ -0,0 +1,88 @@
+import { SortState } from '../data/common/sort-state.type.js';
+
+/**
+ * The texts the table speaks to screen reader users: announcements of the live region (sorting, filter, copy,
+ * select all) and the accessible names of controls the table renders (row checkboxes, header group toggles).
+ *
+ * The defaults are English ({@link AriaTexts}). Override single functions – e.g. for another language – with
+ * {@link TableOptionsIf.ariaTexts}; the others keep their default.
+ *
+ * Every function returns plain text. It is written with `textContent` / `setAttribute`, never as HTML,
+ * so data in it (column labels, group labels) needs no escaping.
+ *
+ * @example
+ * const tableOptions: TableOptionsIf = {
+ *   ...new TableOptions(),
+ *   ariaTexts: {
+ *     filtered: (rowCount: number) => `${rowCount} Zeilen`,
+ *     sorted: (column: string, state: SortState) => state ? `Sortiert nach ${column}` : `Sortierung entfernt`,
+ *   },
+ * };
+ *
+ * @since 1.1.91
+ * @see Training: [Accessible tables: keyboard and screen readers](https://gui.expert/training/accessibility/)
+ * @category Accessibility
+ */
+export interface AriaTextsIf {
+    /**
+     * Announced after a column was sorted (header double click, Enter on a header cell, {@link TableApi.sortByColumn}).
+     *
+     * @param {string} columnLabel - the header label of the column
+     * @param {SortState} sortState - the new sort state, `""` = unsorted
+     * @returns {string} default: `"Sorted by Total, descending"`, `"Sorting of Total removed"`
+     */
+    sorted(columnLabel: string, sortState: SortState): string;
+    /**
+     * Announced after the external filter changed ({@link TableApi.externalFilterChanged}).
+     *
+     * @param {number} rowCount - the number of rows the body shows now
+     * @returns {string} default: `"42 rows"`, `"1 row"`, `"No rows"`
+     */
+    filtered(rowCount: number): string;
+    /**
+     * Announced after cells were copied to the clipboard (Ctrl/⌘+C, {@link TableApi.copyToClipboard}).
+     *
+     * @param {number} cellCount - the number of copied cells
+     * @returns {string} default: `"12 cells copied"`, `"1 cell copied"`
+     */
+    copied(cellCount: number): string;
+    /**
+     * Announced after Ctrl/⌘+A.
+     *
+     * @returns {string} default: `"All cells selected"`
+     */
+    allSelected(): string;
+    /**
+     * Announced after the selection was cleared by the keyboard (e.g. Ctrl+Shift+A).
+     *
+     * @returns {string} default: `"Selection cleared"`
+     */
+    selectionCleared(): string;
+    /**
+     * The accessible name of the checkbox of a body row.
+     *
+     * @param {number} rowNumber - 1-based number of the row in the body
+     * @returns {string} default: `"Select row 5"`
+     */
+    selectRow(rowNumber: number): string;
+    /**
+     * The accessible name of the checkbox in the header (checks all rows).
+     *
+     * @returns {string} default: `"Select all rows"`
+     */
+    selectAllRows(): string;
+    /**
+     * The accessible name of the toggle button of a collapsed header group.
+     *
+     * @param {string} groupLabel - the label of the group
+     * @returns {string} default: `"Expand group Q1"`
+     */
+    expandGroup(groupLabel: string): string;
+    /**
+     * The accessible name of the toggle button of an expanded header group.
+     *
+     * @param {string} groupLabel - the label of the group
+     * @returns {string} default: `"Collapse group Q1"`
+     */
+    collapseGroup(groupLabel: string): string;
+}

package/lib/table/aria/live-announcer.d.ts

@@ -0,0 +1,53 @@
+import { DomServiceIf } from '../service/dom-service.if.js';
+
+/**
+ * A polite live region (`role="status"`) that lets screen readers speak short messages: "Sorted by Total,
+ * descending", "42 rows", "12 cells copied" … Every table has one ({@link TableApi.announce}).
+ *
+ * The element lives in `document.body`, not in the table: a `role="grid"` may only contain rows, and the body is
+ * never managed by a framework. The table creates it in `firstInit()` – before the first message. Known limit: inside
+ * a modal dialog (`aria-modal="true"`) screen readers ignore content outside the dialog; announce such messages with
+ * a live region of your own in the dialog. It is visually hidden (inline styles – it works without the table CSS, e.g. outside
+ * a shadow root) and removed by {@link destroy} (called by `TableScope.destroy()`).
+ *
+ * The text is written with `textContent` (never HTML). It is set after a short delay and the region is emptied
+ * first, so the same message is announced again, and a burst of messages (typing in a filter field) ends with one
+ * announcement of the last one.
+ *
+ * @example
+ * const announcer = new LiveAnnouncer(document, "orders-live", new SimpleDomService());
+ * announcer.announce("Orders loaded");
+ * // later
+ * announcer.destroy();
+ *
+ * @since 1.1.91
+ * @category Accessibility
+ */
+export declare class LiveAnnouncer {
+    private readonly document;
+    private readonly id;
+    private readonly domService;
+    /** Delay in ms before a message is written (default for {@link announce}). */
+    static defaultDelayInMs: number;
+    private element?;
+    private timeout?;
+    constructor(document: Document | undefined, id: string, domService: DomServiceIf);
+    /**
+     * Speaks a message (replaces a message that is still waiting).
+     *
+     * @param {string} text - plain text
+     * @param {number} [delayInMs=LiveAnnouncer.defaultDelayInMs] - wait this long before the text is written
+     */
+    announce(text: string, delayInMs?: number): void;
+    /**
+     * The live region element (created on the first call).
+     *
+     * @returns {HTMLElement | undefined} undefined without a document body (e.g. server side rendering)
+     */
+    getElement(): HTMLElement | undefined;
+    /**
+     * Cancels a waiting message and removes the live region from the document.
+     */
+    destroy(): void;
+    private getOrCreateElement;
+}