@scion/components 22.5.0 → 22.6.0

package/types/scion-components-table.d.ts

@@ -9,7 +9,7 @@ type MaybeAsync<T> = T | Promise<T> | Observable<T>;
 
 interface SciTableColumnFilter {
     columnName: `column:${string}`;
-    text: string | boolean | number;
+    text: string | number | boolean | SciEnumValueLike | SciEnumValueLike[];
 }
 interface SciTableSortCriterion {
     columnName: `column:${string}`;
@@ -47,22 +47,60 @@ type SciTableDataLoaderFn<T> = (request: SciTablePageRequest) => MaybeAsync<SciT
  */
 declare function ɵillegaldatasource<T>(): Signal<T[]>;
 
-declare function provideTableRowBinding<T = unknown>(bindings: SciTableRowBindingFactoryFn<T>): Provider;
-type SciTableRowBindingFactoryFn<T> = (bindings: SciTableRowBindingFactory, item: T, index: number) => void;
+/**
+ * Provides row bindings to tables in the scope of the injector providing the bindings.
+ *
+ * Multiple providers can be registered. Providers at different injector tree levels form a hierarchy.
+ */
+declare function provideTableRowBinding<T = unknown>(bindings: SciTableRowBindingFactoryFn<T>): Provider[];
+/**
+ * Signature of a function to configure row bindings.
+ *
+ * Called per item with a {@link SciTableRowBindingFactory} to register bindings.
+ *
+ * The function:
+ * - Runs in a reactive context and re-evaluates when tracked signals change.
+ * - Can call `inject` to get required dependencies.
+ */
+type SciTableRowBindingFactoryFn<T> = (row: SciTableRowBindingFactory, item: T, index: number) => void;
+/**
+ * Factory for configuring row bindings.
+ *
+ * Row bindings enable associating metadata and icons with a row. Metadata includes CSS shadow parts, CSS classes, and HTML attributes.
+ */
 interface SciTableRowBindingFactory {
-    addAttributeBinding(name: string, value: unknown | undefined): this;
-    addClassBinding(name: string | undefined): this;
     /**
-     * Adds the specified values as part attributes to the row, enabling for custom styling of the row, e.g., based on a condition.
+     * Binds an icon to the row, displayed in the first column.
+     *
+     * ```ts
+     * import {table} from '@scion/components/table';
+     *
+     * table({
+     *   datasource: data,
+     *   columns: table => ...,
+     *   rowBindings: bindings => bindings.addIconBinding('account_circle'),
+     * });
+     * ```
+     *
+     * SCION uses icon providers to render icons. An icon provider can be registered using {@link provideIconProvider}.
+     *
+     * Defaults to a Material icon provider if the application has not registered an icon provider, interpreting the icon as a Material Icon font ligature.
+     * Refer to https://fonts.google.com/icons for available Material icons and instructions on including the Material icon font.
+     */
+    addIconBinding(icon: string): this;
+    /**
+     * Binds a CSS shadow part to the row for custom row/cell styling using the `::part()` CSS pseudo-element selector.
      *
      * Example usage:
      * ```ts
+     * import {table} from '@scion/components/table';
+     *
      * table({
      *   datasource: data,
+     *   columns: table => ...,
      *   rowBindings: (bindings, item, index) => bindings
      *     .addPartBinding(index % 2 === 0 ? 'row:even' : 'row:odd')
      *     .addPartBinding(item.active ? 'row:active' : undefined),
-     *   columns: table => ...,
      * });
      * ```
      *
@@ -77,21 +115,69 @@ interface SciTableRowBindingFactory {
      * ```
      */
     addPartBinding(name: `row:${string}` | undefined): this;
+    /**
+     * Binds an HTML attribute to the row.
+     *
+     * Useful for end-to-end testing, such as associating a row with an item's primary key.
+     *
+     * ```ts
+     * import {table} from '@scion/components/table';
+     *
+     * table({
+     *   datasource: data,
+     *   columns: table => ...,
+     *   rowBindings: (bindings, item) => bindings.addAttributeBinding('data-id', item.id),
+     * });
+     * ```
+     */
+    addAttributeBinding(name: string, value: unknown | undefined): this;
+    /**
+     * Binds a CSS class to the row.
+     */
+    addClassBinding(name: string | undefined): this;
 }
 interface SciTableRowBindings {
-    cssClass: Signal<string[]>;
+    icons: Signal<string[]>;
+    parts: Signal<`row:${string}`[]>;
     attributes: Signal<{
         [name: string]: unknown;
     }>;
-    part: Signal<`row:${string}`[]>;
+    classes: Signal<string[]>;
 }
 
 interface SciTableColumnFactory<T> {
-    addStringColumn(header: Translatable, value: (item: T) => MaybeSignal<string | undefined>): this;
-    addStringColumn(value: (item: T) => MaybeSignal<string | undefined>): this;
+    /**
+     * Adds a column to the table for displaying text.
+     *
+     * The value can be plain text or a translation key. A translation key starts with the percent symbol (`%`)
+     * and may include parameters in matrix notation for text interpolation.
+     *
+     * SCION uses text providers to resolve translation keys. A text provider can be registered using {@link provideTextProvider}.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
+    addStringColumn(header: SciColumnHeaderLike, value: (item: T) => MaybeSignal<Translatable | undefined>): this;
+    /**
+     * Adds a column to the table for displaying text.
+     *
+     * The value can be plain text or a translation key. A translation key starts with the percent symbol (`%`)
+     * and may include parameters in matrix notation for text interpolation.
+     *
+     * SCION uses text providers to resolve translation keys. A text provider can be registered using {@link provideTextProvider}.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
+    addStringColumn(value: (item: T) => MaybeSignal<Translatable | undefined>): this;
+    /**
+     * Adds a column to the table for displaying text.
+     */
     addStringColumn(descriptor: SciStringColumnDescriptor<T>): this;
     /**
-     * Adds a number column to the table for displaying numeric values.
+     * Adds a column to the table for displaying numeric values.
      *
      * ### Tabular Figures
      * Numbers are rendered using tabular (fixed-width) figures to align digits vertically in fonts with varying character widths. Has no effect on monospaced fonts.
@@ -111,10 +197,14 @@ interface SciTableColumnFactory<T> {
      *   font-variant-numeric: normal;
      * }
      * ```
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
      */
-    addNumberColumn(header: Translatable, value: (item: T) => MaybeSignal<number | undefined>): this;
+    addNumberColumn(header: SciColumnHeaderLike, value: (item: T) => MaybeSignal<number | undefined>): this;
     /**
-     * Adds a number column to the table for displaying numeric values.
+     * Adds a column to the table for displaying numeric values.
      *
      * ### Tabular Figures
      * Numbers are rendered using tabular (fixed-width) figures to align digits vertically in fonts with varying character widths. Has no effect on monospaced fonts.
@@ -134,10 +224,14 @@ interface SciTableColumnFactory<T> {
      *   font-variant-numeric: normal;
      * }
      * ```
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
      */
     addNumberColumn(value: (item: T) => MaybeSignal<number | undefined>): this;
     /**
-     * Adds a number column to the table for displaying numeric values.
+     * Adds a column to the table for displaying numeric values.
      *
      * ### Tabular Figures
      * Numbers are rendered using tabular (fixed-width) figures to align digits vertically in fonts with varying character widths. Has no effect on monospaced fonts.
@@ -159,11 +253,37 @@ interface SciTableColumnFactory<T> {
      * ```
      */
     addNumberColumn(descriptor: SciNumberColumnDescriptor<T>): this;
-    addBooleanColumn(header: Translatable, value: (item: T) => MaybeSignal<boolean | undefined>): this;
+    /**
+     * Adds a column to the table for displaying boolean values.
+     *
+     * Cells display `true` as a checkmark and `false` as an 'X'. Filter options are labeled as 'Yes'/'No'.
+     * For custom display or filter options, use {@link addEnumColumn} instead.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
+    addBooleanColumn(header: SciColumnHeaderLike, value: (item: T) => MaybeSignal<boolean | undefined>): this;
+    /**
+     * Adds a column to the table for displaying boolean values.
+     *
+     * Cells display `true` as a checkmark and `false` as an 'X'. Filter options are labeled as 'Yes'/'No'.
+     * For custom display or filter options, use {@link addEnumColumn} instead.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
     addBooleanColumn(value: (item: T) => MaybeSignal<boolean | undefined>): this;
+    /**
+     * Adds a column to the table for displaying boolean values.
+     *
+     * Cells display `true` as a checkmark and `false` as an 'X'. Filter options are labeled as 'Yes'/'No'.
+     * For custom display or filter options, use {@link addEnumColumn} instead.
+     */
     addBooleanColumn(descriptor: SciBooleanColumnDescriptor<T>): this;
     /**
-     * Adds a temporal column to the table for displaying dates, times, or both.
+     * Adds a column to the table for displaying dates, times, or both.
      *
      * Supports ISO 8601 date/time strings, milliseconds since the UTC epoch, and `Date` objects.
      *
@@ -187,10 +307,14 @@ interface SciTableColumnFactory<T> {
      *   font-variant-numeric: normal;
      * }
      * ```
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
      */
-    addDateColumn(header: Translatable, value: (item: T) => MaybeSignal<SciDateLike | undefined>): this;
+    addDateColumn(header: SciColumnHeaderLike, value: (item: T) => MaybeSignal<SciDateLike | undefined>): this;
     /**
-     * Adds a temporal column to the table for displaying dates, times, or both.
+     * Adds a column to the table for displaying dates, times, or both.
      *
      * Supports ISO 8601 date/time strings, milliseconds since the UTC epoch, and `Date` objects.
      *
@@ -214,10 +338,14 @@ interface SciTableColumnFactory<T> {
      *   font-variant-numeric: normal;
      * }
      * ```
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
      */
     addDateColumn(value: (item: T) => MaybeSignal<SciDateLike | undefined>): this;
     /**
-     * Adds a temporal column to the table for displaying dates, times, or both.
+     * Adds a column to the table for displaying dates, times, or both.
      *
      * Supports ISO 8601 date/time strings, milliseconds since the UTC epoch, and `Date` objects.
      *
@@ -243,12 +371,31 @@ interface SciTableColumnFactory<T> {
      * ```
      */
     addDateColumn(descriptor: SciDateColumnDescriptor<T>): this;
+    /**
+     * Adds a column to the table for displaying values of an enumeration.
+     *
+     * An enumeration defines a fixed set of values, each with a label and an optional icon and tooltip.
+     */
+    addEnumColumn(descriptor: SciEnumColumnDescriptor<T>): this;
+    /**
+     * Adds a column to the table for displaying icons.
+     *
+     * An icon column is a standardized enum column for displaying icons. If configured with only a header icon and no label,
+     * it defaults to non-resizable and sizes to fit the icon.
+     */
+    addIconColumn(descriptor: SciIconColumnDescriptor<T>): this;
+    /**
+     * Adds a column to the table for displaying custom content using a component.
+     */
     addComponentColumn(descriptor: SciComponentColumnDescriptor<T>): this;
+    /**
+     * Adds a column to the table for displaying custom content using a template.
+     */
     addTemplateColumn(descriptor: SciTemplateColumnDescriptor<T>): this;
 }
 interface SciTableColumnDescriptor {
     name?: `column:${string}`;
-    header?: Translatable;
+    header?: SciColumnHeaderLike;
     resizable?: boolean;
     /**
      * Preferred column size.
@@ -261,8 +408,22 @@ interface SciTableColumnDescriptor {
      */
     minWidth?: number;
 }
+/**
+ * Configures a table column for displaying text.
+ */
 interface SciStringColumnDescriptor<T> extends SciTableColumnDescriptor {
-    value: (item: T) => MaybeSignal<string | undefined>;
+    /**
+     * Specifies the text to display for an item.
+     *
+     * Can be text or a translation key. A translation key starts with the percent symbol (`%`) and may include parameters in matrix notation for text interpolation.
+     *
+     * SCION uses text providers to resolve translation keys. A text provider can be registered using {@link provideTextProvider}.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
+    value: (item: T) => MaybeSignal<Translatable | undefined>;
     sortable?: boolean | {
         comparator: SciTableColumnSortComparatorFn<T, string>;
     };
@@ -275,7 +436,11 @@ interface SciStringColumnDescriptor<T> extends SciTableColumnDescriptor {
  */
 interface SciNumberColumnDescriptor<T> extends SciTableColumnDescriptor {
     /**
-     * Specifies the number to display in this column.
+     * Specifies the number to display for an item.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
      */
     value: (item: T) => MaybeSignal<number | undefined>;
     /**
@@ -366,9 +531,28 @@ interface SciNumberColumnDescriptor<T> extends SciTableColumnDescriptor {
      */
     locale?: MaybeSignal<string>;
 }
+/**
+ * Configures a table column for displaying boolean values.
+ */
 interface SciBooleanColumnDescriptor<T> extends SciTableColumnDescriptor {
+    /**
+     * Specifies the boolean value to display for an item.
+     *
+     * Cells display `true` as a checkmark and `false` as an 'X'. Filter options are labeled as 'Yes'/'No'.
+     * For custom display or filter options, use {@link addEnumColumn} instead.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
     value: (item: T) => MaybeSignal<boolean | undefined>;
+    /**
+     * Controls whether the user can sort this column. Defaults to `true`.
+     */
     sortable?: boolean;
+    /**
+     * Controls whether the user can filter this column. Defaults to `true`.
+     */
     filterable?: boolean;
 }
 /**
@@ -376,9 +560,13 @@ interface SciBooleanColumnDescriptor<T> extends SciTableColumnDescriptor {
  */
 interface SciDateColumnDescriptor<T> extends SciTableColumnDescriptor {
     /**
-     * Specifies the date value to display in this column.
+     * Specifies the date value to display for an item.
      *
      * Can be an ISO 8601 date/time string (e.g., `2026-10-06`, `2026-10-06T14:30:15Z`, `T14:30:15`), milliseconds since the UTC epoch, or a `Date` object.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
      */
     value: (item: T) => MaybeSignal<SciDateLike | undefined>;
     /**
@@ -420,6 +608,94 @@ interface SciDateColumnDescriptor<T> extends SciTableColumnDescriptor {
      */
     timezone?: string;
 }
+/**
+ * Configures a table column for displaying values of an enumeration.
+ *
+ * An enumeration defines a fixed set of values, each with a label and an optional icon and tooltip.
+ */
+interface SciEnumColumnDescriptor<T = unknown> extends SciTableColumnDescriptor {
+    /**
+     * Specifies the enumeration value to display for an item. Must be a value of an entry defined in {@link values}.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
+    value: (item: T) => MaybeSignal<SciEnumValueLike | undefined>;
+    /**
+     * Specifies the enumeration entries.
+     *
+     * The array order determines the sort order of the enumeration.
+     */
+    values: MaybeSignal<SciEnumColumnValues>;
+    /**
+     * Configures the display of enumeration values.
+     *
+     * Defaults to displaying the label in cells, and both icon and label in the column filter menu. Defaults are unset when using a custom format.
+     */
+    format?: {
+        /**
+         * Controls whether to display the icon in cells.
+         */
+        icon?: true;
+        /**
+         * Controls whether to display the label in cells.
+         */
+        label?: true;
+        /**
+         * Configures the display of entries in the column filter menu.
+         */
+        filter?: {
+            /**
+             * Controls whether to display the icon in the column filter menu.
+             */
+            icon?: true;
+        };
+    };
+    /**
+     * Controls whether the user can sort this column. Defaults to `true`.
+     */
+    sortable?: boolean;
+    /**
+     * Controls whether the user can filter this column. Defaults to `multi`.
+     */
+    filterable?: 'single' | 'multi' | false;
+}
+/**
+ * Configures a table column for displaying icons.
+ *
+ * An icon column is a standardized enum column for displaying icons. If configured with only a header icon and no label,
+ * it defaults to non-resizable and sizes to fit the icon.
+ */
+interface SciIconColumnDescriptor<T = unknown> extends SciTableColumnDescriptor {
+    /**
+     * Specifies the icon to display for an item.
+     *
+     * SCION uses icon providers to render icons. An icon provider can be registered using {@link provideIconProvider}.
+     *
+     * Defaults to a Material icon provider if the application has not registered an icon provider, interpreting the icon as a Material Icon font ligature.
+     * Refer to https://fonts.google.com/icons for available Material icons and instructions on including the Material icon font.
+     *
+     * The function:
+     * - Can call `inject` to get required dependencies.
+     * - Can call `toSignal` to convert an {@link Observable} to a {@link Signal}.
+     */
+    value: (item: T) => MaybeSignal<string | number | boolean | undefined>;
+    /**
+     * Specifies the icons displayed in this column.
+     *
+     * The array order determines the sort order.
+     */
+    values: MaybeSignal<SciIconColumnValues>;
+    /**
+     * Controls whether the user can sort this column. Defaults to `true`.
+     */
+    sortable?: boolean;
+    /**
+     * Controls whether the user can filter this column. Defaults to `multi`.
+     */
+    filterable?: 'single' | 'multi' | false;
+}
 interface SciComponentColumnDescriptor<T> extends SciTableColumnDescriptor {
     component: (item: T) => SciComponentDescriptor;
     sortable?: boolean | {
@@ -477,8 +753,22 @@ interface SciDateValue {
     formatted: string;
 }
 
-type SciTableColumnType = 'string' | 'number' | 'boolean' | 'date' | 'component' | 'template';
-type SciTableRowActionFactoryFn<T> = (toolbar: SciToolbarFactory, item: T, index: number) => void;
+/**
+ * Represents the internal value of {@link SciEnumColumn}.
+ */
+interface SciEnumValue {
+    value: SciEnumValueLike;
+    /** localized text */
+    label: string;
+    /** localized tooltip */
+    tooltip?: string;
+    icon?: string;
+}
+
+/**
+ * Represents supported column types of {@link SciTableComponent}.
+ */
+type SciTableColumnType = 'string' | 'number' | 'boolean' | 'date' | 'icon' | 'enum' | 'component' | 'template';
 interface SciTableDescriptor<T> {
     datasource: Signal<T[]>;
     /**
@@ -490,7 +780,7 @@ interface SciTableDescriptor<T> {
     sortable?: boolean;
     resizable?: boolean;
     filterable?: boolean;
-    selectable?: false | 'single' | 'multi';
+    selectable?: 'single' | 'multi' | false;
     showHeader?: boolean;
     /**
      * Defaults to false.
@@ -499,39 +789,62 @@ interface SciTableDescriptor<T> {
     /**
      * Configures actions to show when hovering over a row.
      *
-     * Example usage:
+     * @example
      * ```ts
+     * import {table} from '@scion/components/table';
+     *
      * table({
      *   datasource: data,
+     *   columns: table => ...,
      *   rowActions: (toolbar, item) => toolbar.addToolbarButton({
      *     icon: 'delete',
      *     onSelect: () => ...,
      *   }),
-     *   columns: table => ...,
      * });
      * ```
+     *
+     * The function:
+     * - Is called per item with a {@link SciToolbarFactory} to contribute actions.
+     * - Runs in a reactive context and re-evaluates when tracked signals change.
+     * - Can call `inject` to get required dependencies.
      */
     rowActions?: SciTableRowActionFactoryFn<T>;
     /**
-     * Adds bindings to a table row, enabling custom styling, HTML attributes, and CSS classes.
+     * Configures row bindings for table rows.
      *
-     * Example usage:
+     * Row bindings enable associating metadata and icons with a row. Metadata includes CSS shadow parts, CSS classes, and HTML attributes.
+     *
+     * @example
      * ```ts
+     * import {table} from '@scion/components/table';
+     *
      * table({
      *   datasource: data,
+     *   columns: table => ...,
      *   rowBindings: (bindings, item, index) => bindings
+     *     .addIconBinding('account_circle')
      *     .addPartBinding(index % 2 === 0 ? 'row:even' : 'row:odd')
      *     .addAttributeBinding('data-id', item.id)
      *     .addClassBinding(item.inactive ? 'inactive' : undefined),
-     *   columns: table => ...,
      * });
      * ```
      *
+     * Part attribute bindings make a row stylable by associating its cells with one or more HTML part attributes that can be referenced in CSS using the `::part()` CSS pseudo-element selector.
+     *
      * ```scss
      * sci-table::part(row\:even row\:not\:selected) {
      *   background-color: lightgray;
      * }
      * ```
+     *
+     * The function:
+     * - Is called per item with a {@link SciTableRowBindingFactory} to register bindings.
+     * - Runs in a reactive context and re-evaluates when tracked signals change.
+     * - Can call `inject` to get required dependencies.
+     *
+     * @param bindings - Factory providing methods to register row bindings.
+     * @param item - Item associated with the row.
+     * @param index - Index of the row, zero-based.
      */
     rowBindings?: SciTableRowBindingFactoryFn<T>;
     /**
@@ -568,7 +881,11 @@ interface SciTable<T> {
 interface SciTableColumn<T = unknown, VALUE = unknown, FILTER = VALUE> {
     type: SciTableColumnType;
     name: `column:${string}`;
-    header: Signal<string>;
+    header: {
+        icon: string | undefined;
+        label: Signal<string> | undefined;
+        tooltip: Signal<string> | undefined;
+    };
     sortable: Signal<boolean>;
     filterable: Signal<boolean>;
     resizable: Signal<boolean>;
@@ -586,41 +903,39 @@ interface SciTableColumn<T = unknown, VALUE = unknown, FILTER = VALUE> {
 interface SciStringColumn<T = unknown> extends SciTableColumn<T, string> {
     type: 'string';
     value: (item: T) => Signal<string | undefined>;
-    compare: SciTableColumnSortComparatorFn<T, string>;
-    matches: SciTableColumnFilterMatcherFn<T, string>;
 }
 interface SciNumberColumn<T = unknown> extends SciTableColumn<T, number> {
     type: 'number';
     value: (item: T) => Signal<number | undefined>;
-    compare: SciTableColumnSortComparatorFn<T, number>;
-    matches: SciTableColumnFilterMatcherFn<T, number>;
     format: Signal<Intl.NumberFormat>;
 }
-interface SciBooleanColumn<T = unknown> extends SciTableColumn<T, boolean> {
-    type: 'boolean';
-    value: (item: T) => Signal<boolean | undefined>;
-    compare: SciTableColumnSortComparatorFn<T, boolean>;
-    matches: SciTableColumnFilterMatcherFn<T, boolean>;
-}
 interface SciDateColumn<T = unknown> extends SciTableColumn<T, SciDateValue, string> {
     type: 'date';
     value: (item: T) => Signal<SciDateValue | undefined>;
-    compare: SciTableColumnSortComparatorFn<T, SciDateValue>;
-    matches: SciTableColumnFilterMatcherFn<T, SciDateValue, string>;
+}
+interface SciEnumColumn<T = unknown> extends Omit<SciTableColumn<T, SciEnumValue, SciEnumValueLike[] | string>, 'filterable'> {
+    type: 'enum';
+    value: (item: T) => Signal<SciEnumValue | undefined>;
+    filterable: Signal<'single' | 'multi' | false>;
+    enumeration: Signal<SciEnumColumnValues>;
+    format: {
+        icon: boolean;
+        label: boolean;
+        filter: {
+            icon: boolean;
+        };
+    };
+    referenceType: SciTableColumnType | undefined;
 }
 interface SciComponentColumn<T = unknown> extends SciTableColumn<T, void, string> {
     type: 'component';
     component: (item: T) => SciComponentDescriptor;
-    compare: SciTableColumnSortComparatorFn<T, void>;
-    matches: SciTableColumnFilterMatcherFn<T, void, string>;
 }
 interface SciTemplateColumn<T = unknown> extends SciTableColumn<T, void, string> {
     type: 'template';
     template: (item: T) => SciTemplateDescriptor;
-    compare: SciTableColumnSortComparatorFn<T, void>;
-    matches: SciTableColumnFilterMatcherFn<T, void, string>;
 }
-type SciTableColumnLike<T = unknown> = SciStringColumn<T> | SciNumberColumn<T> | SciBooleanColumn<T> | SciDateColumn<T> | SciComponentColumn<T> | SciTemplateColumn<T>;
+type SciTableColumnLike<T = unknown> = SciStringColumn<T> | SciNumberColumn<T> | SciDateColumn<T> | SciEnumColumn<T> | SciComponentColumn<T> | SciTemplateColumn<T>;
 /**
  * Mapped row, used as display state.
  */
@@ -645,16 +960,16 @@ interface SciNumberCell {
     column: SciNumberColumn;
     value: Signal<number | undefined>;
 }
-interface SciBooleanCell {
-    type: 'boolean';
-    column: SciBooleanColumn;
-    value: Signal<boolean | undefined>;
-}
 interface SciDateCell {
     type: 'date';
     column: SciDateColumn;
     value: Signal<SciDateValue | undefined>;
 }
+interface SciEnumCell {
+    type: 'enum';
+    column: SciEnumColumn;
+    value: Signal<SciEnumValue | undefined>;
+}
 interface SciComponentCell {
     type: 'component';
     column: SciComponentColumn;
@@ -665,11 +980,21 @@ interface SciTemplateCell {
     column: SciTemplateColumn;
     template: SciTemplateDescriptor;
 }
-type SciTableCellLike = SciStringCell | SciNumberCell | SciBooleanCell | SciDateCell | SciComponentCell | SciTemplateCell;
+type SciTableCellLike = SciStringCell | SciNumberCell | SciDateCell | SciEnumCell | SciComponentCell | SciTemplateCell;
 interface SciTableCellContext<T = unknown, VALUE = unknown> {
     item: T;
     value: VALUE;
 }
+/**
+ * Signature of a function to contribute row actions.
+ *
+ * Called per item with a {@link SciToolbarFactory} to contribute actions.
+ *
+ * The function:
+ * - Runs in a reactive context and re-evaluates when tracked signals change.
+ * - Can call `inject` to get required dependencies.
+ */
+type SciTableRowActionFactoryFn<T> = (toolbar: SciToolbarFactory, item: T, index: number) => void;
 /**
  * Represents an event emitted by {@link SciTableComponent}.
  */
@@ -684,9 +1009,65 @@ interface SciTableEvent<T> {
     items: T[];
 }
 /**
- * Represents an ISO 8601 date/time string, milliseconds since the UTC epoch, or a `Date` object.
+ * Represents the header of a table column, defined as a {@link Translatable} or an object with an optional icon, label, and tooltip.
+ *
+ * The label can be text or a translation key. A translation key starts with the percent symbol (`%`) and may include parameters in matrix notation for text interpolation.
+ * SCION uses text providers to resolve translation keys. A text provider can be registered using {@link provideTextProvider}.
+ *
+ * SCION uses icon providers to render icons. An icon provider can be registered using {@link provideIconProvider}.
+ *
+ * Defaults to a Material icon provider if the application has not registered an icon provider, interpreting the icon as a Material Icon font ligature.
+ * Refer to https://fonts.google.com/icons for available Material icons and instructions on including the Material icon font.
+ */
+type SciColumnHeaderLike = Translatable | {
+    icon?: string;
+    label?: Translatable;
+    tooltip?: Translatable;
+};
+/**
+ * An ISO 8601 date/time string, milliseconds since the UTC epoch, or a {@link Date} object.
  */
 type SciDateLike = string | number | Date;
+/**
+ * Supported data types for enumeration values used in an enum column.
+ */
+type SciEnumValueLike = string | number | boolean;
+/**
+ * Defines the enumeration entries of an enum column.
+ *
+ * The array order determines the sort order of the enumeration.
+ *
+ * A label can be text or a translation key. A translation key starts with the percent symbol (`%`) and may include parameters in matrix notation for text interpolation.
+ * SCION uses text providers to resolve translation keys. A text provider can be registered using {@link provideTextProvider}.
+ *
+ * SCION uses icon providers to render icons. An icon provider can be registered using {@link provideIconProvider}.
+ * Defaults to a Material icon provider if the application has not registered an icon provider, interpreting the icon as a Material Icon font ligature.
+ * Refer to https://fonts.google.com/icons for available Material icons and instructions on including the Material icon font.
+ */
+type SciEnumColumnValues = {
+    value: SciEnumValueLike;
+    label: Translatable;
+    icon?: string;
+    tooltip?: Translatable | null;
+}[];
+/**
+ * Defines icons of an icon column.
+ *
+ * The array order determines the sort order.
+ *
+ * A label can be text or a translation key. A translation key starts with the percent symbol (`%`) and may include parameters in matrix notation for text interpolation.
+ * SCION uses text providers to resolve translation keys. A text provider can be registered using {@link provideTextProvider}.
+ *
+ * SCION uses icon providers to render icons. An icon provider can be registered using {@link provideIconProvider}.
+ * Defaults to a Material icon provider if the application has not registered an icon provider, interpreting the icon as a Material Icon font ligature.
+ * Refer to https://fonts.google.com/icons for available Material icons and instructions on including the Material icon font.
+ */
+type SciIconColumnValues = {
+    value: string | number | boolean;
+    label: Translatable;
+    icon: string;
+    tooltip?: Translatable | null;
+}[];
 
 type SciTableColumnFactoryFn<T> = (table: SciTableColumnFactory<T>) => void;
 /** @experimental since 22.3.0; API and behavior may change in any version without notice. */
@@ -789,7 +1170,7 @@ declare class ɵSciTable<T = unknown> implements SciTable<T> {
      * Applies a filter, either via global filter or on a specific column.
      */
     filter(text: string | null): void;
-    filter(text: string | number | boolean | null, options: {
+    filter(text: string | number | boolean | SciEnumValueLike | SciEnumValueLike[] | null, options: {
         columnName: `column:${string}`;
     }): void;
     updateSelectedItems(updateFn: (ids: Map<unknown, T>) => Map<unknown, T>): void;
@@ -914,4 +1295,4 @@ interface SciTableStorage {
 declare function provideTableStorage(storage: Type<SciTableStorage>): EnvironmentProviders;
 
 export { SciTableComponent, provideTableRowBinding, provideTableStorage, table, ɵillegaldatasource };
-export type { SciBooleanColumnDescriptor, SciComponentColumnDescriptor, SciDateColumnDescriptor, SciDateLike, SciNumberColumnDescriptor, SciStringColumnDescriptor, SciTable, SciTableCellContext, SciTableColumnDescriptor, SciTableColumnFactory, SciTableColumnFactoryFn, SciTableColumnFilter, SciTableColumnFilterMatcherFn, SciTableColumnSortComparatorFn, SciTableColumnType, SciTableDataLoaderFn, SciTableDescriptor, SciTableEvent, SciTablePageRequest, SciTablePageResponse, SciTableRowActionFactoryFn, SciTableRowBindingFactory, SciTableRowBindingFactoryFn, SciTableSortCriterion, SciTableStorage, SciTemplateColumnDescriptor };
+export type { SciBooleanColumnDescriptor, SciColumnHeaderLike, SciComponentColumnDescriptor, SciDateColumnDescriptor, SciDateLike, SciEnumColumnDescriptor, SciEnumColumnValues, SciEnumValueLike, SciIconColumnDescriptor, SciIconColumnValues, SciNumberColumnDescriptor, SciStringColumnDescriptor, SciTable, SciTableCellContext, SciTableColumnDescriptor, SciTableColumnFactory, SciTableColumnFactoryFn, SciTableColumnFilter, SciTableColumnFilterMatcherFn, SciTableColumnSortComparatorFn, SciTableColumnType, SciTableDataLoaderFn, SciTableDescriptor, SciTableEvent, SciTablePageRequest, SciTablePageResponse, SciTableRowActionFactoryFn, SciTableRowBindingFactory, SciTableRowBindingFactoryFn, SciTableSortCriterion, SciTableStorage, SciTemplateColumnDescriptor };