@trylight/app 0.1.8 → 0.2.0

package/dist/client.d.ts

@@ -1,14 +1,67 @@
-import type { Contracts } from "@shubh90/app-runtime/invoke/server";
+import { type QueryKey } from "@tanstack/react-query";
+import type { Contracts } from "./invoke/server.js";
 import { EntityError, type ListOptions, type NewRow, type Patch, type Row } from "./entities.js";
 import type { Entity } from "./schema.js";
 export { EntityError, LIST_LIMIT, type ListOptions, type NewRow, type Sort, type Patch, type Row, type Where } from "./entities.js";
 export type { FieldSource, FieldSources } from "./schema.js";
 export { siteOf } from "./schema.js";
 export { imageSrc } from "./images.js";
-export { InvocationError, type InvocationStatus } from "@shubh90/app-runtime/invoke";
+export { InvocationError, type InvocationStatus } from "./invoke/index.js";
 export declare function createApp<C extends Contracts = Record<never, never>>(): {
     table: typeof tableClient;
-    contracts: import("@shubh90/app-runtime/invoke").Invoker<C>;
+    contracts: import("./invoke/index.js").Invoker<C>;
+};
+/** Rows one page of `useInfiniteList` asks for; scrolling near the end asks for the next. */
+export declare const PAGE_SIZE = 100;
+/** A column, and which way: what a table header sorts by. */
+export type Sorting = {
+    column: string;
+    desc: boolean;
+};
+/** What `useInfiniteList` takes: a list's options, less the paging it does itself. */
+export type PageOptions<R> = Omit<ListOptions<R>, "limit" | "offset"> & {
+    /** Rows per page; PAGE_SIZE unless a page needs fewer or more. */
+    pageSize?: number;
+};
+/**
+ * A list as a table draws it (DataTable's `list`): its rows, whether more
+ * exist, and how to get them. `useList` and `useInfiniteList` both give one.
+ */
+export type ListView<R> = {
+    rows: R[];
+    /** Nothing to show yet: the first answer is on its way. */
+    isPending: boolean;
+    /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+    loadError: Error | null;
+    refetch: () => unknown;
+    /** More rows exist than are loaded (useList: it stopped at its limit). */
+    hasMore: boolean;
+    /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+    loadMore: (() => void) | null;
+    isLoadingMore: boolean;
+    /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+    moreFailed: boolean;
+    /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+    isSwitching: boolean;
+    /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+    serverSort: {
+        sorting: Sorting | null;
+        setSorting: (next: Sorting | null) => void;
+        canSort: (column: string) => boolean;
+    } | null;
+};
+/**
+ * Where one row sat in a cached query before a write: its value, page and
+ * place, to put it back if the write fails. `fields` are the ones the write
+ * changed (an update's patch), so a failure takes back only those and never
+ * another save's change to the same row; null (a delete) is the whole row.
+ */
+type Before = {
+    key: QueryKey;
+    page: number;
+    index: number;
+    row: unknown;
+    fields: string[] | null;
 };
 /** One entity table's rows: plain calls, and TanStack Query hooks over them. */
 declare function tableClient<T extends Entity>(entity: T): {
@@ -31,10 +84,29 @@ declare function tableClient<T extends Entity>(entity: T): {
      */
     useList: (options?: ListOptions<Row<T>>) => {
         rows: (T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
         data: (T["$inferSelect"] extends infer T_2 ? { [K in keyof T_2]: Date extends T_2[K] ? string | Exclude<T_2[K], T_2[K] & Date> : T_2[K]; } : never)[];
         error: EntityError;
         isError: true;
-        isPending: false;
         isLoading: false;
         isLoadingError: false;
         isRefetchError: true;
@@ -54,14 +126,32 @@ declare function tableClient<T extends Entity>(entity: T): {
         isRefetching: boolean;
         isStale: boolean;
         isEnabled: boolean;
-        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_3 ? { [K in keyof T_3]: Date extends T_3[K] ? string | Exclude<T_3[K], T_3[K] & Date> : T_3[K]; } : never)[], EntityError>>;
         fetchStatus: import("@tanstack/react-query").FetchStatus;
     } | {
         rows: (T["$inferSelect"] extends infer T_3 ? { [K in keyof T_3]: Date extends T_3[K] ? string | Exclude<T_3[K], T_3[K] & Date> : T_3[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
         data: (T["$inferSelect"] extends infer T_4 ? { [K in keyof T_4]: Date extends T_4[K] ? string | Exclude<T_4[K], T_4[K] & Date> : T_4[K]; } : never)[];
         error: null;
         isError: false;
-        isPending: false;
         isLoading: false;
         isLoadingError: false;
         isRefetchError: false;
@@ -81,14 +171,32 @@ declare function tableClient<T extends Entity>(entity: T): {
         isRefetching: boolean;
         isStale: boolean;
         isEnabled: boolean;
-        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_5 ? { [K in keyof T_5]: Date extends T_5[K] ? string | Exclude<T_5[K], T_5[K] & Date> : T_5[K]; } : never)[], EntityError>>;
         fetchStatus: import("@tanstack/react-query").FetchStatus;
     } | {
         rows: (T["$inferSelect"] extends infer T_5 ? { [K in keyof T_5]: Date extends T_5[K] ? string | Exclude<T_5[K], T_5[K] & Date> : T_5[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
         data: undefined;
         error: EntityError;
         isError: true;
-        isPending: false;
         isLoading: false;
         isLoadingError: true;
         isRefetchError: false;
@@ -108,14 +216,32 @@ declare function tableClient<T extends Entity>(entity: T): {
         isRefetching: boolean;
         isStale: boolean;
         isEnabled: boolean;
-        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_6 ? { [K in keyof T_6]: Date extends T_6[K] ? string | Exclude<T_6[K], T_6[K] & Date> : T_6[K]; } : never)[], EntityError>>;
         fetchStatus: import("@tanstack/react-query").FetchStatus;
     } | {
         rows: (T["$inferSelect"] extends infer T_6 ? { [K in keyof T_6]: Date extends T_6[K] ? string | Exclude<T_6[K], T_6[K] & Date> : T_6[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
         data: undefined;
         error: null;
         isError: false;
-        isPending: true;
         isLoading: true;
         isLoadingError: false;
         isRefetchError: false;
@@ -135,14 +261,32 @@ declare function tableClient<T extends Entity>(entity: T): {
         isRefetching: boolean;
         isStale: boolean;
         isEnabled: boolean;
-        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_7 ? { [K in keyof T_7]: Date extends T_7[K] ? string | Exclude<T_7[K], T_7[K] & Date> : T_7[K]; } : never)[], EntityError>>;
         fetchStatus: import("@tanstack/react-query").FetchStatus;
     } | {
         rows: (T["$inferSelect"] extends infer T_7 ? { [K in keyof T_7]: Date extends T_7[K] ? string | Exclude<T_7[K], T_7[K] & Date> : T_7[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
         data: undefined;
         error: null;
         isError: false;
-        isPending: true;
         isLoadingError: false;
         isRefetchError: false;
         isSuccess: false;
@@ -162,14 +306,32 @@ declare function tableClient<T extends Entity>(entity: T): {
         isRefetching: boolean;
         isStale: boolean;
         isEnabled: boolean;
-        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_8 ? { [K in keyof T_8]: Date extends T_8[K] ? string | Exclude<T_8[K], T_8[K] & Date> : T_8[K]; } : never)[], EntityError>>;
         fetchStatus: import("@tanstack/react-query").FetchStatus;
     } | {
         rows: (T["$inferSelect"] extends infer T_8 ? { [K in keyof T_8]: Date extends T_8[K] ? string | Exclude<T_8[K], T_8[K] & Date> : T_8[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
         data: (T["$inferSelect"] extends infer T_9 ? { [K in keyof T_9]: Date extends T_9[K] ? string | Exclude<T_9[K], T_9[K] & Date> : T_9[K]; } : never)[];
         isError: false;
         error: null;
-        isPending: false;
         isLoading: false;
         isLoadingError: false;
         isRefetchError: false;
@@ -189,19 +351,355 @@ declare function tableClient<T extends Entity>(entity: T): {
         isRefetching: boolean;
         isStale: boolean;
         isEnabled: boolean;
-        refetch: (options?: import("@tanstack/react-query").RefetchOptions) => Promise<import("@tanstack/react-query").QueryObserverResult<(T["$inferSelect"] extends infer T_10 ? { [K in keyof T_10]: Date extends T_10[K] ? string | Exclude<T_10[K], T_10[K] & Date> : T_10[K]; } : never)[], EntityError>>;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    };
+    /**
+     * A list of any size, a page at a time: `loadMore` (DataTable calls it as
+     * the end scrolls into view) fetches the next. New options (a tab, a
+     * filter, a search) keep the last rows on screen with `isSwitching` until
+     * theirs land, so a click never blanks the table. `prefetch` names the
+     * sibling views (the other tabs): their first pages load once this one
+     * settles, so switching to one is instant. Sorting is the server's, over
+     * every row; `sort` is where it starts.
+     *
+     *   const list = app.table(leads).useInfiniteList({ where: { status: tab } }, { prefetch: TABS.map((t) => ({ where: { status: t } })) });
+     *   <DataTable list={list} … />
+     */
+    useInfiniteList: (options?: PageOptions<Row<T>>, { prefetch }?: {
+        prefetch?: PageOptions<Row<T>>[];
+    }) => {
+        rows: (T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
+        data: import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_2 ? { [K in keyof T_2]: Date extends T_2[K] ? string | Exclude<T_2[K], T_2[K] & Date> : T_2[K]; } : never)[], unknown>;
+        error: Error;
+        isError: true;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: true;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "error";
+        fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_3 ? { [K in keyof T_3]: Date extends T_3[K] ? string | Exclude<T_3[K], T_3[K] & Date> : T_3[K]; } : never)[], unknown>, Error>>;
+        fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_3 ? { [K in keyof T_3]: Date extends T_3[K] ? string | Exclude<T_3[K], T_3[K] & Date> : T_3[K]; } : never)[], unknown>, Error>>;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        isFetchNextPageError: boolean;
+        isFetchingNextPage: boolean;
+        isFetchPreviousPageError: boolean;
+        isFetchingPreviousPage: boolean;
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_3 ? { [K in keyof T_3]: Date extends T_3[K] ? string | Exclude<T_3[K], T_3[K] & Date> : T_3[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
+        data: import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_4 ? { [K in keyof T_4]: Date extends T_4[K] ? string | Exclude<T_4[K], T_4[K] & Date> : T_4[K]; } : never)[], unknown>;
+        error: null;
+        isError: false;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isFetchNextPageError: false;
+        isFetchPreviousPageError: false;
+        isSuccess: true;
+        isPlaceholderData: false;
+        status: "success";
+        fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_5 ? { [K in keyof T_5]: Date extends T_5[K] ? string | Exclude<T_5[K], T_5[K] & Date> : T_5[K]; } : never)[], unknown>, Error>>;
+        fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_5 ? { [K in keyof T_5]: Date extends T_5[K] ? string | Exclude<T_5[K], T_5[K] & Date> : T_5[K]; } : never)[], unknown>, Error>>;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        isFetchingNextPage: boolean;
+        isFetchingPreviousPage: boolean;
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_5 ? { [K in keyof T_5]: Date extends T_5[K] ? string | Exclude<T_5[K], T_5[K] & Date> : T_5[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
+        data: undefined;
+        error: Error;
+        isError: true;
+        isLoading: false;
+        isLoadingError: true;
+        isRefetchError: false;
+        isFetchNextPageError: false;
+        isFetchPreviousPageError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "error";
+        fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_6 ? { [K in keyof T_6]: Date extends T_6[K] ? string | Exclude<T_6[K], T_6[K] & Date> : T_6[K]; } : never)[], unknown>, Error>>;
+        fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_6 ? { [K in keyof T_6]: Date extends T_6[K] ? string | Exclude<T_6[K], T_6[K] & Date> : T_6[K]; } : never)[], unknown>, Error>>;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        isFetchingNextPage: boolean;
+        isFetchingPreviousPage: boolean;
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_6 ? { [K in keyof T_6]: Date extends T_6[K] ? string | Exclude<T_6[K], T_6[K] & Date> : T_6[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
+        data: undefined;
+        error: null;
+        isError: false;
+        isLoading: true;
+        isLoadingError: false;
+        isRefetchError: false;
+        isFetchNextPageError: false;
+        isFetchPreviousPageError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "pending";
+        fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_7 ? { [K in keyof T_7]: Date extends T_7[K] ? string | Exclude<T_7[K], T_7[K] & Date> : T_7[K]; } : never)[], unknown>, Error>>;
+        fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_7 ? { [K in keyof T_7]: Date extends T_7[K] ? string | Exclude<T_7[K], T_7[K] & Date> : T_7[K]; } : never)[], unknown>, Error>>;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        isFetchingNextPage: boolean;
+        isFetchingPreviousPage: boolean;
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_7 ? { [K in keyof T_7]: Date extends T_7[K] ? string | Exclude<T_7[K], T_7[K] & Date> : T_7[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
+        data: undefined;
+        error: null;
+        isError: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isFetchNextPageError: false;
+        isFetchPreviousPageError: false;
+        isSuccess: false;
+        isPlaceholderData: false;
+        status: "pending";
+        fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_8 ? { [K in keyof T_8]: Date extends T_8[K] ? string | Exclude<T_8[K], T_8[K] & Date> : T_8[K]; } : never)[], unknown>, Error>>;
+        fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_8 ? { [K in keyof T_8]: Date extends T_8[K] ? string | Exclude<T_8[K], T_8[K] & Date> : T_8[K]; } : never)[], unknown>, Error>>;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        isFetchingNextPage: boolean;
+        isFetchingPreviousPage: boolean;
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isLoading: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
+        fetchStatus: import("@tanstack/react-query").FetchStatus;
+    } | {
+        rows: (T["$inferSelect"] extends infer T_8 ? { [K in keyof T_8]: Date extends T_8[K] ? string | Exclude<T_8[K], T_8[K] & Date> : T_8[K]; } : never)[];
+        /** Nothing to show yet: the first answer is on its way. */
+        isPending: boolean;
+        /** Why the first answer failed (a refetch that fails keeps the rows); `refetch` asks again. */
+        loadError: Error | null;
+        refetch: () => unknown;
+        /** More rows exist than are loaded (useList: it stopped at its limit). */
+        hasMore: boolean;
+        /** Loads the next page; null when this list can't (useList: raise the limit or page it). */
+        loadMore: (() => void) | null;
+        isLoadingMore: boolean;
+        /** The last page asked for failed: `loadMore` asks again, and nothing asks by itself until then. */
+        moreFailed: boolean;
+        /** Showing the last options' rows while the new options' load (a tab or filter just changed). */
+        isSwitching: boolean;
+        /** Sorted by the server, which sees every row; null when the table sorts what's loaded. */
+        serverSort: {
+            sorting: Sorting | null;
+            setSorting: (next: Sorting | null) => void;
+            canSort: (column: string) => boolean;
+        } | null;
+        data: import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_9 ? { [K in keyof T_9]: Date extends T_9[K] ? string | Exclude<T_9[K], T_9[K] & Date> : T_9[K]; } : never)[], unknown>;
+        isError: false;
+        error: null;
+        isLoading: false;
+        isLoadingError: false;
+        isRefetchError: false;
+        isSuccess: true;
+        isPlaceholderData: true;
+        isFetchNextPageError: false;
+        isFetchPreviousPageError: false;
+        status: "success";
+        fetchNextPage: (options?: import("@tanstack/react-query").FetchNextPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_10 ? { [K in keyof T_10]: Date extends T_10[K] ? string | Exclude<T_10[K], T_10[K] & Date> : T_10[K]; } : never)[], unknown>, Error>>;
+        fetchPreviousPage: (options?: import("@tanstack/react-query").FetchPreviousPageOptions) => Promise<import("@tanstack/react-query").InfiniteQueryObserverResult<import("@tanstack/react-query").InfiniteData<(T["$inferSelect"] extends infer T_10 ? { [K in keyof T_10]: Date extends T_10[K] ? string | Exclude<T_10[K], T_10[K] & Date> : T_10[K]; } : never)[], unknown>, Error>>;
+        hasNextPage: boolean;
+        hasPreviousPage: boolean;
+        isFetchingNextPage: boolean;
+        isFetchingPreviousPage: boolean;
+        dataUpdatedAt: number;
+        errorUpdatedAt: number;
+        failureCount: number;
+        failureReason: Error | null;
+        errorUpdateCount: number;
+        isFetched: boolean;
+        isFetchedAfterMount: boolean;
+        isFetching: boolean;
+        isInitialLoading: boolean;
+        isPaused: boolean;
+        isRefetching: boolean;
+        isStale: boolean;
+        isEnabled: boolean;
         fetchStatus: import("@tanstack/react-query").FetchStatus;
     };
     /** One row; `null` waits (nothing open yet). */
     useGet: (id: string | null) => import("@tanstack/react-query").UseQueryResult<T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never, EntityError>;
     useCreate: () => import("@tanstack/react-query").UseMutationResult<T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never, EntityError, NewRow<T>, unknown>;
-    /** Shows the patch at once in every cached list and row. */
+    /**
+     * Shows the patch at once in every cached list, page and row under the
+     * table's key; a save that fails takes it back at once (and the mutation's
+     * error says why), then the table refetches.
+     */
     useUpdate: () => import("@tanstack/react-query").UseMutationResult<T["$inferSelect"] extends infer T_1 ? { [K in keyof T_1]: Date extends T_1[K] ? string | Exclude<T_1[K], T_1[K] & Date> : T_1[K]; } : never, EntityError, {
         id: string;
         patch: Patch<T>;
-    }, unknown>;
-    /** Takes the row out of every cached list at once. */
-    useDelete: () => import("@tanstack/react-query").UseMutationResult<void, EntityError, string, unknown>;
+    }, Before[]>;
+    /** Takes the row out of every cached list at once; a delete that fails puts it back. */
+    useDelete: () => import("@tanstack/react-query").UseMutationResult<void, EntityError, string, Before[]>;
 };
 export type TableClient<T extends Entity> = ReturnType<typeof tableClient<T>>;
 /** To the login page, and back here after. */