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;
}
/**
 * Creates a default (ungrouped) table item group that wraps all items under the {@link NO_GROUPS_ID} identifier.
 *
 * Used when no explicit grouping function is provided to the table.
 *
 * @param items - The array of items to include in the default group.
 * @returns A default group containing all the provided items.
 */
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>;
}
/**
 * Creates a factory that produces injection component configs for rendering date column headers.
 *
 * The factory initializes each {@link DbxTableDateHeaderComponent} with the column's date metadata.
 *
 * @returns A factory function that maps a date column to its header injection config.
 */
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: Maybe<D>): DateRange<D>;
    createPreview(activeDate: Maybe<D>): 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>;
}
/**
 * Creates an injection component config for a date-range day-distance input cell.
 *
 * Initializes the component with the provided configuration for day distance, date bounds, and button format.
 *
 * @param componentConfig - Optional configuration for the date range input (day distance, min/max dates, button format)
 * @returns An injection component config that renders a {@link DbxTableDateRangeDayDistanceInputCellInputComponent}
 */
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>;
/**
 * Type guard that checks whether a table view element is a group element (header or footer).
 *
 * @param element - The table view element to check.
 * @returns `true` if the element represents a group header or footer row.
 */
declare function isDbxTableViewGroupElement<T, G>(element: DbxTableViewElement<T, G>): element is DbxTableViewGroupElement<T, G>;
/**
 * Type guard that checks whether a table view element is an item data element.
 *
 * @param element - The table view element to check.
 * @returns `true` if the element represents an item data row.
 */
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>>;
}
/**
 * Creates a {@link DbxTableReader} that provides reactive access to cell data across all columns and items in the table.
 *
 * @param config - The reader configuration containing the delegate and table store.
 * @returns A {@link DbxTableReader} instance with observable accessors for cell data.
 */
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 };