@scion/components 22.1.0 → 22.3.0

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

@@ -41,8 +41,10 @@ import { SplitterMoveEvent } from '@scion/components/splitter';
  * - --sci-sashbox-splitter-size: Sets the size of the splitter along the main axis.
  * - --sci-sashbox-splitter-size-hover: Sets the size of the splitter along the main axis when hovering it.
  * - --sci-sashbox-splitter-touch-target-size: Sets the touch target size to move the splitter (accessibility).
- * - --sci-sashbox-splitter-cross-axis-size: Sets the splitter size along the cross axis.
- * - --sci-sashbox-splitter-border-radius: Sets the border radius of the splitter.
+ * - --sci-sashbox-splitter-cross-axis-size: Sets the splitter size along the cross-axis. Defaults to `100%`.
+ * - --sci-sashbox-splitter-cross-axis-start: Sets the splitter's start position. Defaults to `auto`.
+ * - --sci-sashbox-splitter-cross-axis-end: Sets the splitter's end position. Defaults to `auto`. Requires `--sci-sashbox-splitter-cross-axis-size: auto`.
+ * - --sci-sashbox-splitter-border-radius: Sets the border radius of the splitter. Defaults to 0.
  * - --sci-sashbox-splitter-opacity-active: Sets the opacity of the splitter while the user moves the splitter.
  * - --sci-sashbox-splitter-opacity-hover: Sets the opacity of the splitter when hovering it.
  *

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

@@ -27,8 +27,10 @@ import * as _angular_core from '@angular/core';
  * - --sci-splitter-size: Sets the size of the splitter along the main axis.
  * - --sci-splitter-size-hover: Sets the size of the splitter along the main axis when hovering it.
  * - --sci-splitter-touch-target-size: Sets the touch target size to move the splitter (accessibility).
- * - --sci-splitter-cross-axis-size: Sets the splitter size along the cross axis.
- * - --sci-splitter-border-radius: Sets the border radius of the splitter.
+ * - --sci-splitter-cross-axis-size: Sets the splitter size along the cross-axis. Defaults to `100%`.
+ * - --sci-splitter-cross-axis-start: Sets the splitter's start position. Defaults to `auto`.
+ * - --sci-splitter-cross-axis-end: Sets the splitter's end position. Defaults to `auto`. Requires `--sci-splitter-cross-axis-size: auto`.
+ * - --sci-splitter-border-radius: Sets the border radius of the splitter. Defaults to 0.
  * - --sci-splitter-opacity-active: Sets the opacity of the splitter while the user moves the splitter.
  * - --sci-splitter-opacity-hover: Sets the opacity of the splitter when hovering it.
  *
@@ -66,7 +68,6 @@ declare class SciSplitterComponent {
     private readonly _cd;
     private readonly _document;
     private readonly _destroyRef;
-    private readonly _touchTarget;
     protected readonly moving: _angular_core.WritableSignal<boolean>;
     protected readonly isHorizontal: _angular_core.Signal<boolean>;
     protected readonly isVertical: _angular_core.Signal<boolean>;

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

@@ -0,0 +1,577 @@
+import * as _angular_core from '@angular/core';
+import { Signal, Provider, WritableSignal, Injector, Type, EnvironmentProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+import { MaybeSignal, SciComponentDescriptor, SciTemplateDescriptor } from '@scion/components/common';
+import { SciToolbarFactory, SciToolbarComponent } from '@scion/components/menu';
+import { Translatable } from '@scion/components/text';
+
+type MaybeAsync<T> = T | Promise<T> | Observable<T>;
+
+interface SciTableColumnFilter {
+    columnName: `column:${string}`;
+    text: string | boolean | number;
+}
+interface SciTableSortCriterion {
+    columnName: `column:${string}`;
+    direction: 'asc' | 'desc';
+}
+interface SciTablePageRequest {
+    page: number;
+    pageSize: number;
+    start: number;
+    end: number;
+    sortCriteria: SciTableSortCriterion[];
+    columnFilters: SciTableColumnFilter[];
+    tableFilter?: string;
+}
+interface SciTablePageResponse<T> {
+    /**
+     * Items of the requested page.
+     */
+    items: T[];
+    /**
+     * Total count of the source data, used to calculate the scroll size.
+     */
+    totalCount: number;
+}
+/**
+ * @docs-private Not public API. For internal use only.
+ * @experimental since 22.3.0; API and behavior may change in any version without notice.
+ */
+type SciTableDataLoaderFn<T> = (request: SciTablePageRequest) => MaybeAsync<SciTablePageResponse<T>>;
+/**
+ * TODO [table] Remove after datasource is final.
+ *
+ * @docs-private Not public API. For internal use only.
+ * @experimental since 22.3.0; API and behavior may change in any version without notice.
+ */
+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;
+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.
+     *
+     * Example usage:
+     * ```ts
+     * table({
+     *   datasource: data,
+     *   rowBindings: (bindings, item, index) => bindings
+     *     .addPartBinding(index % 2 === 0 ? 'row:even' : 'row:odd')
+     *     .addPartBinding(item.active ? 'row:active' : undefined),
+     *   columns: table => ...,
+     * });
+     * ```
+     *
+     * ```scss
+     * sci-table::part(row\:even) {
+     *   background-color: lightgray;
+     * }
+     *
+     * sci-table::part(row\:active) {
+     *   background-color: green;
+     * }
+     * ```
+     */
+    addPartBinding(name: `row:${string}` | undefined): this;
+}
+interface SciTableRowBindings {
+    cssClass: Signal<string[]>;
+    attributes: Signal<{
+        [name: string]: unknown;
+    }>;
+    part: Signal<`row:${string}`[]>;
+}
+
+type SciTableColumnType = 'string' | 'number' | 'boolean' | 'component' | 'template';
+type SciTableRowActionFactoryFn<T> = (toolbar: SciToolbarFactory, item: T, index: number) => void;
+interface SciTableDescriptor<T> {
+    datasource: Signal<T[]>;
+    /**
+     * @docs-private Not public API. For internal use only.
+     * @experimental since 22.3.0; API and behavior may change in any version without notice.
+     */
+    ɵdatasource?: Signal<T[]> | SciTableDataLoaderFn<T>;
+    columns: SciTableColumnFactoryFn<T>;
+    sortable?: boolean;
+    resizable?: boolean;
+    filterable?: boolean;
+    selectable?: false | 'single' | 'multi';
+    showHeader?: boolean;
+    /**
+     * Defaults to false.
+     */
+    wrapHeader?: boolean;
+    /**
+     * Configures actions to show when hovering over a row.
+     *
+     * Example usage:
+     * ```ts
+     * table({
+     *   datasource: data,
+     *   rowActions: (toolbar, item) => toolbar.addToolbarButton({
+     *     icon: 'delete',
+     *     onSelect: () => ...,
+     *   }),
+     *   columns: table => ...,
+     * });
+     * ```
+     */
+    rowActions?: SciTableRowActionFactoryFn<T>;
+    /**
+     * Adds bindings to a table row, enabling custom styling, HTML attributes, and CSS classes.
+     *
+     * Example usage:
+     * ```ts
+     * table({
+     *   datasource: data,
+     *   rowBindings: (bindings, item, index) => bindings
+     *     .addPartBinding(index % 2 === 0 ? 'row:even' : 'row:odd')
+     *     .addAttributeBinding('data-id', item.id)
+     *     .addClassBinding(item.inactive ? 'inactive' : undefined),
+     *   columns: table => ...,
+     * });
+     * ```
+     *
+     * ```scss
+     * sci-table::part(row\:even) {
+     *   background-color: lightgray;
+     * }
+     * ```
+     */
+    rowBindings?: SciTableRowBindingFactoryFn<T>;
+    /**
+     * Specifies the number of items to render before and after the viewport. Defaults to 10.
+     */
+    bufferSize?: number;
+    /**
+     * Specifies the number of items to load per page. Defaults to 50.
+     */
+    pageSize?: number;
+    trackBy?: (item: T) => unknown;
+    injector?: Injector;
+}
+interface SciTable<T> {
+    /**
+     * Currently active item.
+     */
+    readonly activeItem: Signal<T | undefined>;
+    /**
+     * Selected items.
+     */
+    readonly selectedItems: Signal<Array<T>>;
+    readonly filterable: WritableSignal<boolean>;
+    readonly showHeader: WritableSignal<boolean>;
+    readonly wrapHeader: WritableSignal<boolean>;
+    readonly sortable: WritableSignal<boolean>;
+    readonly resizable: WritableSignal<boolean>;
+    readonly selectable: WritableSignal<'single' | 'multi' | false>;
+    filter(text: string | null): void;
+}
+interface SciTableCellContext<T, VALUE> {
+    item: T;
+    value: VALUE;
+}
+interface SciTableColumn {
+    type: SciTableColumnType;
+    name: `column:${string}`;
+    header: Signal<string>;
+    sortable: Signal<boolean>;
+    filterable: Signal<boolean>;
+    resizable: Signal<boolean>;
+    padding: boolean;
+    width: Signal<string>;
+    minWidth: number;
+    resizing: WritableSignal<boolean>;
+    location: {
+        x: number;
+        width: number;
+    };
+}
+interface SciStringColumn<T> extends SciTableColumn {
+    type: 'string';
+    value: (item: T) => MaybeSignal<string>;
+    sort: (a: SciTableCellContext<T, string>, b: SciTableCellContext<T, string>) => number;
+    filter: (text: string, context: SciTableCellContext<T, string>) => boolean;
+}
+interface SciNumberColumn<T> extends SciTableColumn {
+    type: 'number';
+    value: (item: T) => MaybeSignal<number>;
+    sort: (a: SciTableCellContext<T, number>, b: SciTableCellContext<T, number>) => number;
+    filter: (text: number, context: SciTableCellContext<T, number>) => boolean;
+}
+interface SciBooleanColumn<T> extends SciTableColumn {
+    type: 'boolean';
+    value: (item: T) => MaybeSignal<boolean>;
+    sort: (a: SciTableCellContext<T, boolean>, b: SciTableCellContext<T, boolean>) => number;
+    filter: (text: boolean, context: SciTableCellContext<T, boolean>) => boolean;
+}
+interface SciComponentColumn<T> extends SciTableColumn {
+    type: 'component';
+    component: (item: T) => SciComponentDescriptor;
+    sort: (a: SciTableCellContext<T, void>, b: SciTableCellContext<T, void>) => number;
+    filter: (text: string, context: SciTableCellContext<T, void>) => boolean;
+}
+interface SciTemplateColumn<T> extends SciTableColumn {
+    type: 'template';
+    template: (item: T) => SciTemplateDescriptor;
+    sort: (a: SciTableCellContext<T, void>, b: SciTableCellContext<T, void>) => number;
+    filter: (text: string, context: SciTableCellContext<T, void>) => boolean;
+}
+type SciTableColumnLike<T = unknown> = SciStringColumn<T> | SciNumberColumn<T> | SciBooleanColumn<T> | SciComponentColumn<T> | SciTemplateColumn<T>;
+/**
+ * Mapped row, used as display state.
+ */
+interface SciTableRow<T> {
+    index: number;
+    item?: T;
+    id?: unknown;
+    cells?: SciTableCellLike[];
+    bindings?: SciTableRowBindings;
+    loading: boolean;
+    active: Signal<boolean>;
+    selected: Signal<boolean>;
+    hovered: Signal<boolean>;
+}
+interface SciStringCell {
+    type: 'string';
+    column: SciTableColumnLike;
+    value: Signal<string>;
+}
+interface SciNumberCell {
+    type: 'number';
+    column: SciTableColumnLike;
+    value: Signal<number>;
+}
+interface SciBooleanCell {
+    type: 'boolean';
+    column: SciTableColumnLike;
+    value: Signal<boolean>;
+}
+interface SciComponentCell {
+    type: 'component';
+    column: SciTableColumnLike;
+    component: SciComponentDescriptor;
+}
+interface SciTemplateCell {
+    type: 'template';
+    column: SciTableColumnLike;
+    template: SciTemplateDescriptor;
+}
+type SciTableCellLike = SciStringCell | SciNumberCell | SciBooleanCell | SciComponentCell | SciTemplateCell;
+/**
+ * Represents an event emitted by {@link SciTableComponent}.
+ */
+interface SciTableEvent<T> {
+    /**
+     * The native browser event (`MouseEvent` or `KeyboardEvent`) that triggered the action.
+     */
+    sourceEvent: MouseEvent | KeyboardEvent;
+    /**
+     * The items associated with the action.
+     */
+    items: T[];
+}
+
+interface SciTableColumnFactory<T> {
+    addStringColumn(header: Translatable, value: (item: T) => string): this;
+    addStringColumn(value: (item: T) => string): this;
+    addStringColumn(descriptor: SciStringColumnDescriptor<T>): this;
+    addBooleanColumn(header: Translatable, value: (item: T) => boolean): this;
+    addBooleanColumn(value: (item: T) => boolean): this;
+    addBooleanColumn(descriptor: SciBooleanColumnDescriptor<T>): this;
+    addNumberColumn(header: Translatable, value: (item: T) => number): this;
+    addNumberColumn(value: (item: T) => number): this;
+    addNumberColumn(descriptor: SciNumberColumnDescriptor<T>): this;
+    addComponentColumn(descriptor: SciComponentColumnDescriptor<T>): this;
+    addTemplateColumn(descriptor: SciTemplateColumnDescriptor<T>): this;
+}
+interface SciTableColumnDescriptor {
+    name?: `column:${string}`;
+    header?: Translatable;
+    resizable?: boolean;
+    /**
+     * Preferred column size.
+     * Value which can be used inside `grid-template-columns` definition. Defaults to 1fr.
+     * Examples: `1fr`, `max-content`, `100px`.
+     */
+    width?: string;
+    /**
+     * Min column width in px. Defaults to 100.
+     */
+    minWidth?: number;
+}
+interface SciStringColumnDescriptor<T> extends SciTableColumnDescriptor {
+    value: (item: T) => MaybeSignal<string>;
+    sortable?: boolean | {
+        comparator: (a: SciTableCellContext<T, string>, b: SciTableCellContext<T, string>) => number;
+    };
+    filterable?: boolean | {
+        matcher: (text: string, context: SciTableCellContext<T, string>) => boolean;
+    };
+}
+interface SciNumberColumnDescriptor<T> extends SciTableColumnDescriptor {
+    value: (item: T) => MaybeSignal<number>;
+    sortable?: boolean;
+    filterable?: boolean;
+}
+interface SciBooleanColumnDescriptor<T> extends SciTableColumnDescriptor {
+    value: (item: T) => MaybeSignal<boolean>;
+    sortable?: boolean;
+    filterable?: boolean;
+}
+interface SciComponentColumnDescriptor<T> extends SciTableColumnDescriptor {
+    component: (item: T) => SciComponentDescriptor;
+    sortable?: boolean | {
+        comparator: (a: SciTableCellContext<T, void>, b: SciTableCellContext<T, void>) => number;
+    };
+    filterable?: boolean | {
+        matcher: (text: string, context: SciTableCellContext<T, void>) => boolean;
+    };
+    /**
+     * Controls whether cell padding is applied. Set to `false` to let content fill the entire cell (render to cell bounds).
+     *
+     * Defaults to `true`.
+     */
+    padding?: boolean;
+}
+interface SciTemplateColumnDescriptor<T> extends SciTableColumnDescriptor {
+    template: (item: T) => SciTemplateDescriptor;
+    sortable?: boolean | {
+        comparator: (a: SciTableCellContext<T, void>, b: SciTableCellContext<T, void>) => number;
+    };
+    filterable?: boolean | {
+        matcher: (text: string, context: SciTableCellContext<T, void>) => boolean;
+    };
+    /**
+     * Controls whether cell padding is applied. Set to `false` to let content fill the entire cell (render to cell bounds).
+     *
+     * Defaults to `true`.
+     */
+    padding?: boolean;
+}
+
+type SciTableColumnFactoryFn<T> = (table: SciTableColumnFactory<T>) => void;
+/** @experimental since 22.3.0; API and behavior may change in any version without notice. */
+declare function table<T>(descriptor: SciTableDescriptor<T>): SciTable<T>;
+/** @experimental since 22.3.0; API and behavior may change in any version without notice. */
+declare function table<T>(data: Signal<T[]>, columnFactoryFn: SciTableColumnFactoryFn<T>, options?: {
+    injector?: Injector;
+}): SciTable<T>;
+
+declare class ɵSciTable<T = unknown> implements SciTable<T> {
+    private readonly _tableStorage;
+    private readonly _injector;
+    readonly name: WritableSignal<`table:${string}` | undefined>;
+    readonly columns: Signal<SciTableColumnLike<T>[]>;
+    readonly rowActions?: SciTableRowActionFactoryFn<T>;
+    private readonly _rowBindings;
+    private readonly _dataLoaderFn;
+    private readonly _trackBy?;
+    readonly tableViewRef: WritableSignal<SciTableViewRef | undefined>;
+    readonly userSettings: WritableSignal<SciTableUserSettings>;
+    readonly bufferSize: number;
+    readonly pageSize: number;
+    readonly filterable: WritableSignal<boolean>;
+    readonly showHeader: WritableSignal<boolean>;
+    readonly wrapHeader: WritableSignal<boolean>;
+    readonly sortable: WritableSignal<boolean>;
+    readonly resizable: WritableSignal<boolean>;
+    readonly selectable: WritableSignal<'single' | 'multi' | false>;
+    readonly scrollRange: Signal<SciScrollRange | undefined>;
+    readonly scrollTop: Signal<number>;
+    readonly virtualScrollOffset: Signal<{
+        top: number;
+        bottom: number;
+    }>;
+    readonly viewportPageSize: Signal<number>;
+    readonly scrolling: Signal<boolean>;
+    readonly resizing: Signal<boolean>;
+    readonly sortCriteria: WritableSignal<SciTableSortCriterion[]>;
+    readonly filterCriteria: WritableSignal<SciTableColumnFilter[]>;
+    private readonly _cache;
+    private readonly _tableFilter;
+    private readonly _selectedItems;
+    readonly totalCount: WritableSignal<number | undefined>;
+    readonly activeItem: WritableSignal<T | undefined>;
+    readonly hoveredIndex: WritableSignal<number>;
+    readonly criteria: Signal<{
+        sort: SciTableSortCriterion[];
+        filter: SciTableColumnFilter[];
+        tableFilter: string | null;
+    }>;
+    readonly loading: Signal<boolean>;
+    readonly error: Signal<Error | undefined>;
+    readonly activeRow: Signal<SciTableRow<T> | undefined>;
+    readonly hoveredRow: Signal<SciTableRow<T> | undefined>;
+    readonly selectedItems: Signal<T[]>;
+    readonly selectedIds: Signal<Set<unknown>>;
+    readonly rowsByIndex: Signal<Map<number, SciTableRow<T>>>;
+    readonly rows: Signal<SciTableRow<T>[]>;
+    constructor(descriptor: SciTableDescriptor<T>);
+    /**
+     * Connects {@link SciTableComponent} to the model.
+     */
+    connect(name: `table:${string}`, viewRef: SciTableViewRef): void;
+    disconnect(): void;
+    private computeColumns;
+    /**
+     * Computes the rows currently visible in the viewport (+buffer).
+     */
+    private computeRows;
+    /**
+     * Computes the visible row count based on the viewport size.
+     */
+    private computeScrollRange;
+    private computeVirtualScrollOffset;
+    private computeViewportPageSize;
+    /**
+     * Tracks {@link HTMLElement.scrollTop} of the viewport.
+     */
+    private computeScrollTop;
+    /**
+     * Tracks whether currently scrolling the viewport.
+     */
+    private computeScrolling;
+    /**
+     * Loads a range of rows, based on the current sort and filter criteria, into the cache.
+     */
+    loadRange(start: number, end: number): Promise<void>;
+    /**
+     * Loads the requested page from the cache or datasource and returns its loading state with a cancelation handler.
+     */
+    private loadPage;
+    /**
+     * Toggles sort on a column. ASC -> DESC -> No sort
+     *
+     * TODO [ego] Revisit API, do we really want a three-state and implicit toggling logic?
+     */
+    sort(columnName: `column:${string}`, multi: boolean): void;
+    /**
+     * Applies a filter, either via global filter or on a specific column.
+     */
+    filter(text: string | null): void;
+    filter(text: string | number | boolean | null, options: {
+        columnName: `column:${string}`;
+    }): void;
+    updateSelectedItems(updateFn: (ids: Map<unknown, T>) => Map<unknown, T>): void;
+    reset(): void;
+    dispose(): void;
+    /**
+     * Loads a set of pages on criteria or viewport changes.
+     */
+    private installPageLoader;
+    /**
+     * Resets cache on criteria changes.
+     */
+    private installCriteriaWatcher;
+    private initColumn;
+    private mapItemsToRow;
+    /**
+     * Creates a signal to read and write table user settings.
+     */
+    private computeUserSettings;
+    /**
+     * Call trackBy function or fallback to track by object reference.
+     */
+    trackBy(item: T): unknown;
+    private computeActiveRow;
+}
+interface SciScrollRange {
+    /** incluse */
+    start: number;
+    /** exclusive */
+    end: number;
+}
+interface SciTableUserSettings {
+    columns?: {
+        name: string;
+        width?: number;
+    }[];
+}
+interface SciTableViewRef {
+    viewport: HTMLElement;
+    viewportHeight: Signal<number>;
+    viewportWidth: Signal<number>;
+    viewportClientHeight: Signal<number>;
+    viewportClientWidth: Signal<number>;
+    headerHeight: Signal<number>;
+    cellPadding: Signal<number>;
+    itemHeight: Signal<number>;
+    scrollToTop: () => void;
+}
+
+declare class SciTableRowComponent<T> {
+    readonly row: _angular_core.InputSignal<SciTableRow<T>>;
+    readonly primaryAction: _angular_core.OutputEmitterRef<SciTableEvent<T>>;
+    protected readonly table: _angular_core.Signal<ɵSciTable<unknown>>;
+    protected readonly rowActionToolbar: _angular_core.Signal<SciToolbarComponent | undefined>;
+    protected readonly rowActionsToolbarName: `toolbar:${string}`;
+    private readonly _selectionService;
+    constructor();
+    protected onRowClick(event: PointerEvent): void;
+    protected onRowDblClick(event: MouseEvent): void;
+    protected onRowMouseEnter(): void;
+    protected onRowMouseLeave(event: MouseEvent): void;
+    protected onActionToolbarClick(event: PointerEvent): void;
+    private contributeRowActions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SciTableRowComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SciTableRowComponent<any>, "sci-table-row", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; }, { "primaryAction": "primaryAction"; }, never, never, true, never>;
+}
+
+/**
+ * @experimental since 22.3.0; API and behavior may change in any version without notice.
+ */
+declare class SciTableComponent<T = unknown> {
+    /**
+     * Specifies a unique table identifier, used as the key for storing user preferences.
+     */
+    readonly name: _angular_core.InputSignal<`table:${string}`>;
+    /**
+     * Specifies the table definition and datasource.
+     */
+    readonly table: _angular_core.InputSignalWithTransform<ɵSciTable<T>, SciTable<T>>;
+    /**
+     * Emits when the user double-clicks a row or presses `Enter` on selected rows.
+     */
+    readonly primaryAction: _angular_core.OutputEmitterRef<SciTableEvent<T>>;
+    private readonly _viewport;
+    private readonly _viewportClient;
+    private readonly _tableHeader;
+    private readonly _tableBody;
+    private readonly _itemSizeSyntheticElement;
+    private readonly _cellPaddingSyntheticElement;
+    protected readonly rows: _angular_core.Signal<readonly SciTableRowComponent<any>[]>;
+    constructor();
+    protected onRowPrimaryAction(event: SciTableEvent<T>): void;
+    protected onRetry(): void;
+    private connectToModel;
+    private scrollActiveRowIntoViewport;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SciTableComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SciTableComponent<any>, "sci-table", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "table": { "alias": "table"; "required": true; "isSignal": true; }; }, { "primaryAction": "primaryAction"; }, never, never, true, never>;
+}
+
+/**
+ * Provides persistent storage for the sci-table.
+ */
+interface SciTableStorage {
+    /**
+     * Method invoked to load a value from persisted storage.
+     */
+    load(name: `scion.components.table:${string}`): Promise<string | null> | string | null;
+    /**
+     * Method invoked to write a value to persisted storage.
+     */
+    store(name: `scion.components.table:${string}`, value: string): Promise<void> | void;
+}
+/**
+ * Defaults to localStorage persistence.
+ * @param storage
+ */
+declare function provideTableStorage(storage: Type<SciTableStorage>): EnvironmentProviders;
+
+export { SciTableComponent, provideTableRowBinding, provideTableStorage, table, ɵillegaldatasource };
+export type { SciBooleanColumnDescriptor, SciComponentColumnDescriptor, SciNumberColumnDescriptor, SciStringColumnDescriptor, SciTable, SciTableCellContext, SciTableColumnDescriptor, SciTableColumnFactory, SciTableColumnFactoryFn, SciTableColumnFilter, SciTableColumnType, SciTableDataLoaderFn, SciTableDescriptor, SciTableEvent, SciTablePageRequest, SciTablePageResponse, SciTableRowActionFactoryFn, SciTableRowBindingFactory, SciTableRowBindingFactoryFn, SciTableSortCriterion, SciTableStorage, SciTemplateColumnDescriptor };