@dereekb/dbx-web 12.6.21 → 13.0.0

package/types/dereekb-dbx-web-table.d.ts

@@ -0,0 +1,600 @@
+import * as i0 from '@angular/core';
+import { TrackByFunction, OnInit, ElementRef, InjectionToken, Signal } from '@angular/core';
+import * as _dereekb_dbx_core from '@dereekb/dbx-core';
+import { DbxInjectionComponentConfig, DbxInjectionComponentConfigFactory } from '@dereekb/dbx-core';
+import * as _dereekb_util from '@dereekb/util';
+import { Maybe, CssClassesArray, Days, ReadRequiredKeyFunction, PrimativeKey } from '@dereekb/util';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as _dereekb_rxjs from '@dereekb/rxjs';
+import { LoadingState, PageListLoadingState, ObservableOrValue } from '@dereekb/rxjs';
+import { DateRangeDayDistanceInput } from '@dereekb/date';
+import { ComponentStore } from '@ngrx/component-store';
+import { MatDateRangeSelectionStrategy, DateRange } from '@angular/material/datepicker';
+import { FormGroup, FormControl } from '@angular/forms';
+import * as _dereekb_dbx_web from '@dereekb/dbx-web';
+import * as _dereekb_dbx_web_table from '@dereekb/dbx-web/table';
+import { MatTable } from '@angular/material/table';
+
+/**
+ * Delegate used for retrieving data for a table.
+ */
+interface DbxTableContextDataDelegate<I, C, T> {
+    /**
+     * Loads data given the input.
+     *
+     * @param input
+     */
+    loadData(input: I): Observable<LoadingState<DbxTableContextData<I, C, T>>>;
+}
+interface DbxTableContextData<I, C, T> {
+    /**
+     * Original context input
+     */
+    readonly input: I;
+    /**
+     * All columns in this data context.
+     */
+    readonly columns: DbxTableColumn<C>[];
+    /**
+     * All currently loaded items.
+     */
+    readonly items$: Observable<PageListLoadingState<T>>;
+    /**
+     * Loads more items, if applicable.
+     */
+    loadMore?(): void;
+}
+interface DbxTableColumn<C> {
+    /**
+     * Unique column name
+     */
+    readonly columnName: string;
+    /**
+     * Column metadata
+     */
+    readonly meta: C;
+}
+declare const NO_GROUPS_ID = "none";
+/**
+ * Unique identifier used for grouping items together.
+ */
+type DbxTableGroupId = string;
+interface DbxTableItemGroup<T, G = unknown> {
+    readonly groupId: DbxTableGroupId;
+    readonly items: T[];
+    readonly meta: G;
+}
+interface DefaultDbxTableItemGroup<T, G = unknown> extends DbxTableItemGroup<T, G> {
+    readonly groupId: typeof NO_GROUPS_ID;
+    readonly default: true;
+}
+declare function defaultDbxTableItemGroup<T, G = unknown>(items: T[]): DefaultDbxTableItemGroup<T, G>;
+type DbxTableGroupByFunction<T, G = unknown> = (items: T[]) => ObservableOrValue<DbxTableItemGroup<T, G>[]>;
+/**
+ * Delegate used for generating view configurations given the input.
+ */
+interface DbxTableViewDelegate<I = unknown, C = unknown, T = unknown, G = unknown> {
+    /**
+     * Track by
+     */
+    readonly trackBy?: TrackByFunction<T>;
+    /**
+     * If provided, will group items together
+     */
+    readonly groupBy?: DbxTableGroupByFunction<T, G>;
+    /**
+     * Input picker view configuration
+     */
+    readonly inputHeader?: Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Action header view configuration
+     */
+    readonly actionHeader?: Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Full-width summary row view configuration.
+     */
+    readonly fullSummaryRow?: Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Summary row header view configuration.
+     */
+    readonly summaryRowHeader?: Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Summary row end view configuration
+     */
+    readonly summaryRowEnd?: Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Group row header view configuration for a specific group.
+     *
+     * If this function returns undefined, the group row will not be shown.
+     *
+     * @param group
+     */
+    groupHeader?(group: DbxTableItemGroup<T, G>): Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Group row footer view configuration for a specific group.
+     *
+     * If this function returns undefined, the group row will not be shown.
+     *
+     * @param group
+     */
+    groupFooter?(group: DbxTableItemGroup<T, G>): Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Column header view configuration for a specific column.
+     *
+     * @param item
+     */
+    columnHeader?(column: DbxTableColumn<C>): Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Optional column footer view configuration for a specific column.
+     *
+     * @param item
+     */
+    columnFooter?(column: DbxTableColumn<C>): Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Item header view (left-most column for an item row) configuration for a specific item.
+     *
+     * @param item
+     */
+    itemHeader(item: T): Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Item cell view (middle columns for an item row) configuration for a specific item and column.
+     *
+     * @param item
+     */
+    itemCell(column: DbxTableColumn<C>, item: T): Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Item action view (right-most column for an item row) configuration for a specific item.
+     *
+     * @param item
+     */
+    itemAction?(item: T): Maybe<DbxInjectionComponentConfig<any>>;
+    /**
+     * Optional classes to apply to the table.
+     */
+    tableClasses?: CssClassesArray;
+}
+
+/**
+ * A table header component used for rendering date values on the header.
+ */
+declare class DbxTableDateHeaderComponent {
+    readonly left = "E";
+    readonly right = "MMM d";
+    private readonly _dateSignal;
+    readonly dateSignal: i0.Signal<Maybe<Date>>;
+    get date(): Maybe<Date>;
+    set date(date: Maybe<Date>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableDateHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableDateHeaderComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+declare function dbxTableDateHeaderInjectionFactory(): DbxInjectionComponentConfigFactory<DbxTableColumn<Date>, DbxTableDateHeaderComponent>;
+
+interface DbxTableStoreState<I, C, T, G> {
+    /**
+     * Contextual input that is passed to the data delegate.
+     */
+    readonly input: Maybe<I>;
+    /**
+     * Delegate used for retrieving info given the selection.
+     */
+    readonly dataDelegate: Maybe<DbxTableContextDataDelegate<I, C, T>>;
+    /**
+     * Delegate used for retrieving view configurations.
+     */
+    readonly viewDelegate: Maybe<DbxTableViewDelegate<I, C, T, G>>;
+}
+declare class DbxTableStore<I = unknown, C = unknown, T = unknown, G = unknown> extends ComponentStore<DbxTableStoreState<I, C, T, G>> {
+    constructor();
+    readonly loadMore: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
+    readonly input$: Observable<Maybe<I>>;
+    readonly dataDelegate$: Observable<Maybe<DbxTableContextDataDelegate<I, C, T>>>;
+    readonly currentViewDelegate$: Observable<Maybe<DbxTableViewDelegate<I, C, T, G>>>;
+    readonly viewDelegate$: Observable<DbxTableViewDelegate<I, C, T, G>>;
+    readonly tableCssClasses$: Observable<_dereekb_util.CssClassesArray | undefined>;
+    readonly spaceSeparatedTableCssClasses$: Observable<string>;
+    readonly dataState$: Observable<LoadingState<DbxTableContextData<I, C, T>>>;
+    readonly data$: Observable<DbxTableContextData<I, C, T>>;
+    readonly columns$: Observable<DbxTableColumn<C>[]>;
+    readonly itemsState$: Observable<PageListLoadingState<T>>;
+    readonly items$: Observable<T[]>;
+    readonly groupsState$: Observable<LoadingState<DbxTableItemGroup<T, G>[]>>;
+    readonly groups$: Observable<DbxTableItemGroup<T, G>[]>;
+    readonly setInput: (() => void) | ((observableOrValue: Maybe<I> | Observable<Maybe<I>>) => rxjs.Subscription) | (I extends void ? () => void : (observableOrValue: Maybe<I> | Observable<Maybe<I>>) => rxjs.Subscription);
+    readonly setDataDelegate: (() => void) | ((observableOrValue: Maybe<DbxTableContextDataDelegate<I, C, T>> | Observable<Maybe<DbxTableContextDataDelegate<I, C, T>>>) => rxjs.Subscription);
+    readonly setViewDelegate: (() => void) | ((observableOrValue: Maybe<DbxTableViewDelegate<I, C, T, G>> | Observable<Maybe<DbxTableViewDelegate<I, C, T, G>>>) => rxjs.Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableStore<any, any, any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxTableStore<any, any, any, any>>;
+}
+
+declare class DbxTableDateRangeDayDistanceInputCellInputRangeSelectionStrategy<D> implements MatDateRangeSelectionStrategy<D> {
+    private readonly _dateAdapter;
+    private readonly dbxTableDateRangeDayDistanceInputCellInputComponent;
+    selectionFinished(date: D | null): DateRange<D>;
+    createPreview(activeDate: D | null): DateRange<D>;
+    private _createFiveDayRange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableDateRangeDayDistanceInputCellInputRangeSelectionStrategy<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxTableDateRangeDayDistanceInputCellInputRangeSelectionStrategy<any>>;
+}
+interface DbxTableDateRangeDayDistanceInputCellInputComponentConfig {
+    /**
+     * Button format for the dates
+     */
+    readonly buttonFormat?: string;
+    /**
+     * Distance from the start to span.
+     */
+    readonly daysDistance: Days;
+    readonly minDate?: Maybe<Date>;
+    readonly maxDate?: Maybe<Date>;
+}
+declare const DEFAULT_DBX_TABLE_DATE_RANGE_DAY_DISTIANCE_INPUT_CELL_COMPONENT_CONFIG: {
+    daysDistance: number;
+};
+declare const DEFAULT_DBX_TABLE_DATE_RANGE_DAY_BUTTON_FORMAT = "MMM dd";
+/**
+ * Cell input for a DateRangeDayDistanceInput value.
+ */
+declare class DbxTableDateRangeDayDistanceInputCellInputComponent {
+    readonly tableStore: DbxTableStore<DateRangeDayDistanceInput, unknown, unknown, unknown>;
+    private readonly _syncSub;
+    private readonly _valueSub;
+    private readonly _pickerOpenedSignal;
+    private readonly _configSignal;
+    readonly range: FormGroup<{
+        start: FormControl<Maybe<Date>>;
+        end: FormControl<Maybe<Date>>;
+    }>;
+    readonly pickerOpened$: rxjs.Observable<Partial<{
+        start: Maybe<Date>;
+        end: Maybe<Date>;
+    }>>;
+    readonly minDateSignal: i0.Signal<Date | null>;
+    readonly maxDateSignal: i0.Signal<Date | null>;
+    readonly buttonFormatSignal: i0.Signal<string>;
+    readonly rangeValue$: rxjs.Observable<Partial<{
+        start: Maybe<Date>;
+        end: Maybe<Date>;
+    }>>;
+    readonly dateRangeStringSignal: i0.Signal<string>;
+    constructor();
+    get daysDistance(): number;
+    get config(): Maybe<DbxTableDateRangeDayDistanceInputCellInputComponentConfig>;
+    set config(config: Maybe<DbxTableDateRangeDayDistanceInputCellInputComponentConfig>);
+    pickerOpened(): void;
+    pickerClosed(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableDateRangeDayDistanceInputCellInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableDateRangeDayDistanceInputCellInputComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+declare function dbxTableDateRangeDayDistanceInputCellInput(componentConfig?: DbxTableDateRangeDayDistanceInputCellInputComponentConfig): DbxInjectionComponentConfig<DbxTableDateRangeDayDistanceInputCellInputComponent>;
+
+declare class DbxTableDateModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableDateModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxTableDateModule, never, [typeof DbxTableDateHeaderComponent, typeof DbxTableDateRangeDayDistanceInputCellInputComponent], [typeof DbxTableDateHeaderComponent, typeof DbxTableDateRangeDayDistanceInputCellInputComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxTableDateModule>;
+}
+
+declare class DbxTableActionCellComponent {
+    readonly tableStore: DbxTableStore<any, any, any, any>;
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableActionCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableActionCellComponent, "dbx-table-action-cell", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A table header component used for injecting the input picker view.
+ */
+declare class DbxTableInputCellComponent {
+    readonly tableStore: DbxTableStore<any, any, any, any>;
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableInputCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableInputCellComponent, "dbx-table-input-cell", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxTableSummaryEndCellComponent {
+    readonly tableStore: DbxTableStore<any, any, any, any>;
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableSummaryEndCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableSummaryEndCellComponent, "dbx-table-summary-end-cell", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * A table header component used for injecting the input picker view.
+ */
+declare class DbxTableSummaryStartCellComponent {
+    readonly tableStore: DbxTableStore<any, any, any, any>;
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableSummaryStartCellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableSummaryStartCellComponent, "dbx-table-summary-start-cell", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract directive that has a column input.
+ */
+declare class AbstractDbxTableColumnDirective<C> {
+    readonly tableStore: DbxTableStore<unknown, C, unknown, unknown>;
+    readonly column: i0.InputSignal<Maybe<DbxTableColumn<C>>>;
+    readonly column$: rxjs.Observable<DbxTableColumn<C>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxTableColumnDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxTableColumnDirective<any>, never, never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxTableColumnHeaderComponent<C> extends AbstractDbxTableColumnDirective<C> {
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableColumnHeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableColumnHeaderComponent<any>, "dbx-table-column-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxTableColumnFooterComponent<C> extends AbstractDbxTableColumnDirective<C> {
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableColumnFooterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableColumnFooterComponent<any>, "dbx-table-column-footer", never, {}, {}, never, never, true, never>;
+}
+
+type DbxColumnSizeColumnValue = 'head' | 'tail' | number;
+declare class DbxTableColumnSizeDirective {
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly resized: i0.Signal<_dereekb_dbx_web.ResizedEvent>;
+    private readonly _columnsMap;
+    readonly columns$: rxjs.Observable<Map<DbxColumnSizeColumnValue, DbxColumnSizeColumnDirective>>;
+    readonly columnsSignal: i0.Signal<Map<DbxColumnSizeColumnValue, DbxColumnSizeColumnDirective> | undefined>;
+    readonly visibleColumnsSignal: i0.Signal<number>;
+    addColumn(column: DbxColumnSizeColumnDirective): void;
+    removeColumn(column: DbxColumnSizeColumnDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableColumnSizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxTableColumnSizeDirective, "[dbxTableColumnSize]", ["dbxTableColumnSize"], {}, {}, never, never, true, never>;
+}
+/**
+ * References a specific element and the index of the column.
+ */
+declare class DbxColumnSizeColumnDirective implements OnInit {
+    readonly dbxColumnSizeDirective: DbxTableColumnSizeDirective;
+    readonly elementRef: ElementRef<HTMLElement>;
+    readonly index: i0.InputSignal<DbxColumnSizeColumnValue>;
+    constructor();
+    ngOnInit(): void;
+    get width(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxColumnSizeColumnDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxColumnSizeColumnDirective, "[dbx-column-size-column]", never, { "index": { "alias": "dbx-column-size-column"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const DBX_TABLE_COLUMN_SIZE_PARENT_ELEMENT_REF_TOKEN: InjectionToken<ElementRef<HTMLElement>>;
+
+declare const DBX_TABLE_ITEMS_COLUMN_NAME = "_items";
+declare const DBX_TABLE_ACTIONS_COLUMN_NAME = "_actions";
+interface DbxTableViewGroupElement<T, G> {
+    readonly type: 'group';
+    readonly location: 'header' | 'footer';
+    readonly group: DbxTableItemGroup<T, G>;
+}
+interface DbxTableViewItemElement<T, G> {
+    readonly type: 'item';
+    readonly item: T;
+}
+type DbxTableViewElement<T, G> = DbxTableViewGroupElement<T, G> | DbxTableViewItemElement<T, G>;
+declare function isDbxTableViewGroupElement<T, G>(element: DbxTableViewElement<T, G>): element is DbxTableViewGroupElement<T, G>;
+declare function isDbxTableViewItemElement<T, G>(element: DbxTableViewElement<T, G>): element is DbxTableViewItemElement<T, G>;
+/**
+ * A table with fixed content
+ */
+declare class DbxTableViewComponent<I, C, T, G = unknown> {
+    readonly tableStore: DbxTableStore<I, C, T, G>;
+    readonly table: Signal<MatTable<DbxTableViewElement<T, G>>>;
+    readonly DEFAULT_TRACK_BY_FUNCTION: TrackByFunction<any>;
+    readonly scrollDistance: i0.InputSignal<number>;
+    readonly throttleScroll: i0.InputSignal<number>;
+    readonly itemsColumnName = "_items";
+    readonly actionsColumnName = "_actions";
+    readonly innerColumns$: Observable<_dereekb_dbx_web_table.DbxTableColumn<C>[]>;
+    readonly innerColumnNames$: Observable<string[]>;
+    readonly innerColumnsSignal: Signal<_dereekb_dbx_web_table.DbxTableColumn<C>[] | undefined>;
+    readonly innerColumnNamesSignal: Signal<string[] | undefined>;
+    readonly elementsState$: Observable<LoadingState<DbxTableViewElement<T, G>[]>>;
+    readonly elements$: Observable<DbxTableViewElement<T, G>[]>;
+    readonly displayedColumns$: Observable<string[]>;
+    readonly displayedColumnsSignal: Signal<string[]>;
+    readonly trackByFunction$: Observable<TrackByFunction<T>>;
+    readonly inputTrackByFunctionSignal: Signal<TrackByFunction<any> | TrackByFunction<T>>;
+    readonly trackElementByFunctionSignal: Signal<TrackByFunction<DbxTableViewElement<T, G>>>;
+    readonly context: _dereekb_rxjs.MutableLoadingStateContext<unknown, LoadingState<_dereekb_dbx_web_table.DbxTableContextData<I, C, T>>, _dereekb_rxjs.LoadingContextEvent & LoadingState<_dereekb_dbx_web_table.DbxTableContextData<I, C, T>>>;
+    readonly dataLoadingContext: _dereekb_rxjs.MutableLoadingStateContext<unknown, LoadingState<DbxTableViewElement<T, G>[]>, _dereekb_rxjs.LoadingContextEvent & LoadingState<DbxTableViewElement<T, G>[]>>;
+    readonly contextSignal: Signal<LoadingState<_dereekb_dbx_web_table.DbxTableContextData<I, C, T>> | undefined>;
+    readonly dataLoadingContextSignal: Signal<LoadingState<DbxTableViewElement<T, G>[]> | undefined>;
+    readonly viewDelegateSignal: Signal<_dereekb_dbx_web_table.DbxTableViewDelegate<I, C, T, G> | undefined>;
+    readonly elementsSignal: Signal<DbxTableViewElement<T, G>[]>;
+    readonly tableCssClasses: Signal<string | undefined>;
+    onScrollDown(): void;
+    showItemRow(_: number, row: DbxTableViewElement<T, G>): boolean;
+    showGroupHeaderRow(_: number, row: DbxTableViewElement<T, G>): boolean;
+    showGroupFooterRow(_: number, row: DbxTableViewElement<T, G>): boolean;
+    readonly showFooterRowSignal: Signal<boolean | undefined>;
+    readonly showFullSummaryRowSignal: Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableViewComponent<any, any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableViewComponent<any, any, any, any>, "dbx-table-view", never, { "scrollDistance": { "alias": "scrollDistance"; "required": false; "isSignal": true; }; "throttleScroll": { "alias": "throttleScroll"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Directive for providing and configuring a DbxTableStore
+ */
+declare class DbxTableDirective<I, C, T> {
+    readonly tableStore: DbxTableStore<I, C, T, unknown>;
+    readonly dbxTableInput: i0.InputSignal<Maybe<I>>;
+    readonly dbxTableViewDelegate: i0.InputSignal<Maybe<DbxTableViewDelegate<I, C, T, unknown>>>;
+    readonly dbxTableDataDelegate: i0.InputSignal<Maybe<DbxTableContextDataDelegate<I, C, T>>>;
+    protected readonly _setOnTableStoreEffect: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxTableDirective<any, any, any>, "[dbxTable]", never, { "dbxTableInput": { "alias": "dbxTableInput"; "required": false; "isSignal": true; }; "dbxTableViewDelegate": { "alias": "dbxTableViewDelegate"; "required": false; "isSignal": true; }; "dbxTableDataDelegate": { "alias": "dbxTableDataDelegate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract directive that has an element input.
+ */
+declare abstract class AbstractDbxTableGroupDirective<T, C = unknown, G = unknown> {
+    readonly tableStore: DbxTableStore<unknown, C, T, G>;
+    readonly group: i0.InputSignal<Maybe<DbxTableItemGroup<T, G>>>;
+    readonly group$: rxjs.Observable<DbxTableItemGroup<T, G>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxTableGroupDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxTableGroupDirective<any, any, any>, never, never, { "group": { "alias": "group"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxTableGroupHeaderComponent<T> extends AbstractDbxTableGroupDirective<T> {
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<DbxInjectionComponentConfig<unknown>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<DbxInjectionComponentConfig<unknown>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableGroupHeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableGroupHeaderComponent<any>, "dbx-table-group-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxTableGroupFooterComponent<T> extends AbstractDbxTableGroupDirective<T> {
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<DbxInjectionComponentConfig<unknown>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<DbxInjectionComponentConfig<unknown>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableGroupFooterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableGroupFooterComponent<any>, "dbx-table-group-footer", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Abstract directive that has an element input.
+ */
+declare abstract class AbstractDbxTableItemDirective<T, C = unknown> {
+    readonly tableStore: DbxTableStore<unknown, C, T, unknown>;
+    readonly item: i0.InputSignal<Maybe<T>>;
+    readonly item$: rxjs.Observable<Maybe<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxTableItemDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxTableItemDirective<any, any>, never, never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxTableItemActionComponent<T> extends AbstractDbxTableItemDirective<T> {
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<DbxInjectionComponentConfig<unknown>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<DbxInjectionComponentConfig<unknown>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableItemActionComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableItemActionComponent<any>, "dbx-table-item-action", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxTableItemCellComponent<T, C> extends AbstractDbxTableItemDirective<T, C> {
+    readonly column: i0.InputSignal<Maybe<DbxTableColumn<C>>>;
+    readonly column$: rxjs.Observable<Maybe<DbxTableColumn<C>>>;
+    readonly config$: rxjs.Observable<Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableItemCellComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableItemCellComponent<any, any>, "dbx-table-item-cell", never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxTableItemHeaderComponent<T> extends AbstractDbxTableItemDirective<T> {
+    readonly config$: rxjs.Observable<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    readonly configSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<any>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableItemHeaderComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxTableItemHeaderComponent<any>, "dbx-table-item-header", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxTableModule, never, [typeof DbxTableDirective, typeof DbxTableViewComponent], [typeof DbxTableDirective, typeof DbxTableViewComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxTableModule>;
+}
+
+interface DbxTableReaderCellPair<C, T> {
+    readonly column: DbxTableColumn<C>;
+    readonly item: T;
+}
+interface DbxTableReaderCellDataPair<C, T, O> extends DbxTableReaderCellPair<C, T> {
+    readonly value: O;
+}
+/**
+ * Key used for tracking columns.
+ *
+ * Generally the table name is used for this.
+ */
+type DbxTableReaderColumnKey = string;
+/**
+ * Key used for tracking items.
+ *
+ * Generally the item's unique identifier is used for this.
+ */
+type DbxTableReaderItemKey = PrimativeKey;
+/**
+ * Default track by function for DbxTableColumn.
+ *
+ * Returns the column name.
+ *
+ * @param column
+ * @returns
+ */
+declare const DEFAULT_DBX_TABLE_READER_COLUMN_TRACK_BY: ReadRequiredKeyFunction<DbxTableColumn<DbxTableReaderColumnKey>>;
+/**
+ * Function used for tracking unique columns using the column's data.
+ *
+ * If the column key value is the same between those two columns, then the metadata of both columns will be considered the same/equal.
+ */
+type DbxTableReaderColumnTrackByFunction<C> = ReadRequiredKeyFunction<DbxTableColumn<C>, DbxTableReaderColumnKey>;
+/**
+ * Function used for tracking unique columns using the column's data.
+ *
+ * If the column key value is the same between those two columns, then the metadata of both columns will be considered the same/equal.
+ */
+type DbxTableReaderItemTrackByFunction<T> = ReadRequiredKeyFunction<T, DbxTableReaderItemKey>;
+interface DbxTableReaderDelegate<C, T, O> {
+    /**
+     * Retrieves the data for a specific column and item/row.
+     *
+     * @param column
+     * @param item
+     */
+    readItemCellDataForColumn(column: DbxTableColumn<C>, item: T): Observable<O>;
+    /**
+     * Used for tracking unique columns.
+     *
+     * Use if the metadata between columns should be used for unique identification.
+     *
+     * Defaults to using the column name as the key if not defined.
+     */
+    trackColumn?: DbxTableReaderColumnTrackByFunction<C>;
+    /**
+     * Used for tracking unique items/rows.
+     *
+     * Use if the metadata between items should be used for unique identification.
+     *
+     * Defaults to using the item itself as the key if not defined.
+     */
+    trackItem: DbxTableReaderItemTrackByFunction<T>;
+}
+interface DbxTableReaderConfig<C, T, O, G = any> {
+    /**
+     * Delegate used for retrieving the data for a specific column and item/row.
+     */
+    readonly delegate: DbxTableReaderDelegate<C, T, O>;
+    /**
+     * The table store used for retrieving the items.
+     */
+    readonly tableStore: DbxTableStore<any, C, T, G>;
+}
+interface DbxTableReader<C, T, O, G = any> extends DbxTableReaderConfig<C, T, O, G> {
+    /**
+     * Retrieves all cell data pairs for a specific column.
+     */
+    cellDataPairsForColumn(column: DbxTableColumn<C>): Observable<DbxTableReaderCellDataPair<C, T, O>[]>;
+    /**
+     * Retrieves all cell data for a specific column.
+     */
+    cellDataForColumn(column: DbxTableColumn<C>): Observable<O[]>;
+    /**
+     * Retrieves the cell data pair for a specific column and item.
+     *
+     * Returns null if the column is not visible or the item is not found.
+     */
+    cellDataPairForColumnAndItem(column: DbxTableColumn<C>, item: T): Observable<Maybe<DbxTableReaderCellDataPair<C, T, O>>>;
+    /**
+     * Retrieves the cell data for a specific column and item.
+     *
+     * Returns null if the column is not visible or the item is not found.
+     */
+    cellDataForColumnAndItem(column: DbxTableColumn<C>, item: T): Observable<Maybe<O>>;
+}
+declare function dbxTableReader<C, T, O, G = any>(config: DbxTableReaderConfig<C, T, O, G>): DbxTableReader<C, T, O, G>;
+
+export { AbstractDbxTableColumnDirective, AbstractDbxTableGroupDirective, AbstractDbxTableItemDirective, DBX_TABLE_ACTIONS_COLUMN_NAME, DBX_TABLE_COLUMN_SIZE_PARENT_ELEMENT_REF_TOKEN, DBX_TABLE_ITEMS_COLUMN_NAME, DEFAULT_DBX_TABLE_DATE_RANGE_DAY_BUTTON_FORMAT, DEFAULT_DBX_TABLE_DATE_RANGE_DAY_DISTIANCE_INPUT_CELL_COMPONENT_CONFIG, DEFAULT_DBX_TABLE_READER_COLUMN_TRACK_BY, DbxColumnSizeColumnDirective, DbxTableActionCellComponent, DbxTableColumnFooterComponent, DbxTableColumnHeaderComponent, DbxTableColumnSizeDirective, DbxTableDateHeaderComponent, DbxTableDateModule, DbxTableDateRangeDayDistanceInputCellInputComponent, DbxTableDateRangeDayDistanceInputCellInputRangeSelectionStrategy, DbxTableDirective, DbxTableGroupFooterComponent, DbxTableGroupHeaderComponent, DbxTableInputCellComponent, DbxTableItemActionComponent, DbxTableItemCellComponent, DbxTableItemHeaderComponent, DbxTableModule, DbxTableStore, DbxTableSummaryEndCellComponent, DbxTableSummaryStartCellComponent, DbxTableViewComponent, NO_GROUPS_ID, dbxTableDateHeaderInjectionFactory, dbxTableDateRangeDayDistanceInputCellInput, dbxTableReader, defaultDbxTableItemGroup, isDbxTableViewGroupElement, isDbxTableViewItemElement };
+export type { DbxColumnSizeColumnValue, DbxTableColumn, DbxTableContextData, DbxTableContextDataDelegate, DbxTableDateRangeDayDistanceInputCellInputComponentConfig, DbxTableGroupByFunction, DbxTableGroupId, DbxTableItemGroup, DbxTableReader, DbxTableReaderCellDataPair, DbxTableReaderCellPair, DbxTableReaderColumnKey, DbxTableReaderColumnTrackByFunction, DbxTableReaderConfig, DbxTableReaderDelegate, DbxTableReaderItemKey, DbxTableReaderItemTrackByFunction, DbxTableStoreState, DbxTableViewDelegate, DbxTableViewElement, DbxTableViewGroupElement, DbxTableViewItemElement, DefaultDbxTableItemGroup };