import { OnDestroy, WritableSignal } from '@angular/core';
import { Observable } from 'rxjs';
import { BaseModel } from 'verben-workflow-ui/src/lib/models';
import { UtilService } from 'verben-workflow-ui/src/lib/services';
import { CardData, ColumnDefinition, FilterCondition, SortCondition } from 'verben-ng-ui';
import { SearchHandlerService } from '../handlers/search-handler.service';
import { BasePageConfig } from '../models/page-config.interface';
import { BaseDataPageService } from './base-data-page.service';
import { BaseDataPageState } from './base-data-page.state';
import * as i0 from "@angular/core";
/**
 * Abstract facade for base data pages.
 * Orchestrates state, service, and search handler, and surfaces the host app's
 * busy indicator / toasts through UtilService.
 */
export declare abstract class BaseDataPageFacade<T extends BaseModel> implements OnDestroy {
    protected state: BaseDataPageState<T>;
    protected service: BaseDataPageService<T>;
    protected searchHandler: SearchHandlerService;
    protected utilService: UtilService;
    protected config: BasePageConfig<T>;
    private destroy$;
    private cardSelectionCleared;
    /**
     * The saved config record for this page (once loaded/created), retained so
     * successive saves in a session update the same record instead of duplicating.
     */
    private savedOption?;
    constructor(state: BaseDataPageState<T>, service: BaseDataPageService<T>, searchHandler: SearchHandlerService, utilService: UtilService, config: BasePageConfig<T>);
    getConfig(): BasePageConfig<T>;
    getColumns(): ColumnDefinition<T>[];
    get items$(): Observable<T[]>;
    get isLoading$(): Observable<boolean>;
    get totalCount$(): Observable<number>;
    get filters$(): Observable<FilterCondition[]>;
    get sorts$(): Observable<SortCondition[]>;
    get searchTerm$(): Observable<string>;
    get visibleColumns$(): Observable<ColumnDefinition<T>[]>;
    /** Last table/card view (true = table). Restored on load, persisted on change. */
    get isTableView$(): Observable<boolean>;
    getIsTableViewValue(): boolean;
    get cardData(): WritableSignal<CardData[]>;
    get currentCardData(): WritableSignal<CardData | null>;
    /**
     * Emits when a refetch invalidates the current card selection.
     * Card views listen to this to clear their own selection state.
     */
    get cardSelectionCleared$(): Observable<void>;
    loadData(): Promise<void>;
    addItem(item: T): void;
    loadMore(): Promise<void>;
    /**
     * Fetch an arbitrary window without touching page state, honouring the active
     * search, filters and sorts. Backs the export component's dataQueryFunction.
     */
    loadRange(skip: number, limit: number): Promise<T[]>;
    refresh(): Promise<void>;
    onSearch(term: string): void;
    private initializeSearchHandler;
    applyFilters(filters: FilterCondition[]): Promise<void>;
    clearFilters(): Promise<void>;
    applySorts(sorts: SortCondition[]): Promise<void>;
    clearSorts(): Promise<void>;
    updateVisibleColumns(columns: ColumnDefinition<T>[]): void;
    /**
     * Update the table/card view flag WITHOUT persisting. Use for transient or
     * internal switches (e.g. dropping to card view to open a create form).
     */
    setViewState(isTableView: boolean): void;
    /** Record the user's table/card choice and persist it (non-blocking). */
    setView(isTableView: boolean): void;
    /**
     * Restore this page's saved config (via the host UTIL_SERVICE), then load data.
     * Safe to call in place of loadData() from the page's ngOnInit. When the page
     * has no `ui` (opt-out) or nothing is saved / the host doesn't support it, it
     * just loads data.
     */
    restoreSavedConfig(): Promise<void>;
    /**
     * Assemble the current page config and persist it through the host. Fire-and-
     * forget: never awaited, so the triggering UI action is not blocked. No-op when
     * the page opts out of persistence (`ui` unset).
     */
    private persistConfig;
    /** Map ordered saved column ids back onto the config's ColumnDefinitions. */
    private rebuildColumns;
    /** A fresh, unsaved PageFilterTabOption for this page. */
    private newOption;
    selectCard(cardData: CardData | null): void;
    /**
     * Close the detail form.
     *
     * Goes through clearCardSelection rather than `selectCard(null)`: nulling the
     * signal alone only empties the form's fields, because CardDataViewComponent
     * holds its own `currentItem` that keeps the right-hand panel on screen. The
     * cardSelectionCleared$ notification is what lets the component tear that down.
     */
    closeForm(): void;
    /**
     * Open the detail form for a record. Routed through selectCard so table-row
     * edit and card click share one source of truth for the open record — the
     * form template binds the current card, not a separate "selected item".
     * Reuses the matching existing card when there is one.
     */
    openForm(item?: T): void;
    /**
     * Prepend a blank record and open it. Replaces the old approach of inferring
     * "this must be the new one" from a falsy Name, which re-opened the form
     * whenever a refetch happened to contain a blank-named record.
     */
    createItem(blank: T): T;
    /**
     * Stable identity, matching BaseDataPageState.getItemKey. Kept here so the
     * facade can match cards without widening the state's protected seam.
     */
    protected itemKey(item: T): string;
    /**
     * Drop the current card selection because the data it referred to is being
     * replaced. Called by loadData(); deliberately not by loadMore(), which only
     * appends and leaves an existing selection valid.
     */
    protected clearCardSelection(): void;
    /**
     * Stamp the write state a record should be saved with.
     *
     * A record is new only when it has no Code yet (the backend always assigns
     * Code on persisted records). Don't trust the loaded DataState here: records
     * returned from the backend come through unchanged and report DataState
     * 'New', which would force an insert (and thus duplicate) on every edit.
     */
    protected withDataState(item: T): T;
    saveItems(items: T[]): Promise<boolean>;
    deleteItems(itemIds: string[]): Promise<boolean>;
    exportData(): Promise<T[]>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseDataPageFacade<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BaseDataPageFacade<any>>;
}