/** Request/response contract of the backend cursor-paginated list
 * endpoints (see backend CursorPaginationService). */
export interface CursorPageRequest {
    limit: number;
    /** `_id` of the last doc of the previous page (exclusive). */
    startkey?: string;
}
export interface CursorPageResponse {
    docs: any[];
    nextStartkey?: string | null;
    hasMore: boolean;
}
/** Drops all pagination state and remounts the inner FmTable, which
 * resets it to page 0 and triggers `fetchFn` again. */
declare function refresh(): void;
/** Fetch-view-and-sync pipeline for a row (also reachable from custom row
 * slots via the component ref): runs `fetchDetail` behind the cancellable
 * placeholder, emits `detail`, then refreshes the cached row. */
declare function openRowDetail(rowData: any): Promise<void>;
declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
    /** Fetches one page from a cursor-paginated list endpoint. */
    fetchPage: (request: CursorPageRequest) => Promise<CursorPageResponse>;
    /** Rows of the current page (`v-model:rows`), so the owner can read
     * and patch them (e.g. update a row after an edit dialog). */
    rows: any[];
    /** Optional mapping applied to a fetched page before it becomes rows. */
    transform?: ((docs: any[]) => any[] | Promise<any[]>) | undefined;
    pageSize?: number | undefined;
    /** Bump to reset pagination and refetch from the first page. */
    refreshKey?: number | undefined;
    /** Extra loading state OR-ed with the page-fetch loading (e.g. a row
     * action that refetches when done). */
    loading?: boolean | undefined;
    /** Row-click handler run through `runRowAction`: a cancellable loading
     * placeholder shows over the table while the (possibly async) action
     * runs and failures surface via snackbar, so callers just pass the
     * callback. Cancel aborts the passed signal, terminating the request. */
    rowAction?: ((row: any, signal: AbortSignal) => unknown) | undefined;
    /** View API: fetches a row's detail (always the latest revision) on row
     * click, behind the same cancellable placeholder. The component emits
     * `detail` with the result and refreshes the cached row when the
     * revisions diverge (see `detailToRow`), so the list can't contradict
     * the opened detail. Receives the plain row data, not the table row. */
    fetchDetail?: ((rowData: any, signal: AbortSignal) => Promise<any>) | undefined;
    /** Maps a fetched detail back onto its listing row for the cache sync
     * (may be async, e.g. lazy-loading a mapper). Without it, only the
     * row's own fields are refreshed from matching detail fields — needed
     * when the row carries derived fields (counts, previews) the detail
     * doesn't expose directly. */
    detailToRow?: ((detail: any, row: any) => unknown) | undefined;
}>, {
    transform: undefined;
    pageSize: number;
    refreshKey: number;
    loading: boolean;
}>>, {
    refresh: typeof refresh;
    runRowAction: <T>(action: (signal: AbortSignal) => T | Promise<T>) => Promise<T | undefined>;
    openRowDetail: typeof openRowDetail;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    "update:rows": (rows: any[]) => void;
    detail: (detail: any) => void;
}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
    /** Fetches one page from a cursor-paginated list endpoint. */
    fetchPage: (request: CursorPageRequest) => Promise<CursorPageResponse>;
    /** Rows of the current page (`v-model:rows`), so the owner can read
     * and patch them (e.g. update a row after an edit dialog). */
    rows: any[];
    /** Optional mapping applied to a fetched page before it becomes rows. */
    transform?: ((docs: any[]) => any[] | Promise<any[]>) | undefined;
    pageSize?: number | undefined;
    /** Bump to reset pagination and refetch from the first page. */
    refreshKey?: number | undefined;
    /** Extra loading state OR-ed with the page-fetch loading (e.g. a row
     * action that refetches when done). */
    loading?: boolean | undefined;
    /** Row-click handler run through `runRowAction`: a cancellable loading
     * placeholder shows over the table while the (possibly async) action
     * runs and failures surface via snackbar, so callers just pass the
     * callback. Cancel aborts the passed signal, terminating the request. */
    rowAction?: ((row: any, signal: AbortSignal) => unknown) | undefined;
    /** View API: fetches a row's detail (always the latest revision) on row
     * click, behind the same cancellable placeholder. The component emits
     * `detail` with the result and refreshes the cached row when the
     * revisions diverge (see `detailToRow`), so the list can't contradict
     * the opened detail. Receives the plain row data, not the table row. */
    fetchDetail?: ((rowData: any, signal: AbortSignal) => Promise<any>) | undefined;
    /** Maps a fetched detail back onto its listing row for the cache sync
     * (may be async, e.g. lazy-loading a mapper). Without it, only the
     * row's own fields are refreshed from matching detail fields — needed
     * when the row carries derived fields (counts, previews) the detail
     * doesn't expose directly. */
    detailToRow?: ((detail: any, row: any) => unknown) | undefined;
}>, {
    transform: undefined;
    pageSize: number;
    refreshKey: number;
    loading: boolean;
}>>> & Readonly<{
    "onUpdate:rows"?: ((rows: any[]) => any) | undefined;
    onDetail?: ((detail: any) => any) | undefined;
}>, {
    loading: boolean;
    transform: (docs: any[]) => any[] | Promise<any[]>;
    pageSize: number;
    refreshKey: number;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Partial<Record<NonNullable<string | number>, (_: any) => any>>>;
export default _default;
type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: import('vue').PropType<T[K]>;
        required: true;
    };
};
type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};
type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};