@wssto2/vue-core 0.2.0 → 0.3.0

package/dist/bottomDock-BZEiOPYZ.js

@@ -0,0 +1,12 @@
+import { ref as e } from "vue";
+import { d as r } from "./context-Ch1r4fdN.js";
+const [n, m] = r("vue-core.bottomDock");
+function s(t) {
+  const o = e(null);
+  return t.provide(n, o), o;
+}
+export {
+  n as b,
+  s as i,
+  m as u
+};

package/dist/button/Button.vue.d.ts

@@ -38,15 +38,15 @@ declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClick?: ((event: KeyboardEvent | MouseEvent) => any) | undefined;
 }>, {
-    size: "xs" | "sm" | "md" | "lg" | "xl";
+    to: RouteLocationRaw;
+    disabled: boolean;
     type: "button" | "submit";
+    size: "xs" | "sm" | "md" | "lg" | "xl";
     prominence: "primary" | "secondary" | "standard" | "plain" | "link";
     tone: "critical";
     icon: IconName;
     trailingIcon: IconName;
-    to: RouteLocationRaw;
     href: string;
-    disabled: boolean;
     processing: boolean;
     keyboardShortcut: KeyboardShortcut;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/button/index.js

@@ -1,4 +1,4 @@
-import { _ as a, m as o, s as r, u, a as e } from "../Button.vue_vue_type_script_setup_true_lang-B1eZgLae.js";
+import { _ as a, m as o, s as r, u, a as e } from "../Button.vue_vue_type_script_setup_true_lang-CYil8h9z.js";
 export {
   a as Button,
   o as matchesShortcut,

package/dist/chrome-BS3xJcad.js

@@ -0,0 +1,93 @@
+import { getCurrentInstance as p, inject as w, ref as c, shallowRef as T, computed as m, watch as C, toValue as s, onBeforeUnmount as M } from "vue";
+import { d as k } from "./context-Ch1r4fdN.js";
+const y = 30;
+function O() {
+  const l = c(null), a = c(""), u = c(!0), n = T(/* @__PURE__ */ new Map()), v = c(0), r = /* @__PURE__ */ new Map();
+  let f = null, o = null;
+  const d = m(() => Array.from(n.value.values())), h = m(() => d.value.flatMap((e) => e.actions)), i = (e) => m(() => d.value.map((t) => t[e]).filter((t) => t != null).pop() ?? null);
+  return {
+    back: l,
+    title: a,
+    titleInView: u,
+    actions: h,
+    leading: i("leading"),
+    status: i("status"),
+    navTitle: i("navTitle"),
+    documentTitle: i("documentTitle"),
+    hasShell: m(() => v.value > 0),
+    claimShell() {
+      v.value++;
+      let e = !1;
+      return () => {
+        e || v.value--, e = !0;
+      };
+    },
+    claim() {
+      const e = Symbol("page-chrome-owner");
+      return {
+        setBack(t) {
+          f = e, l.value = t;
+        },
+        clearBack() {
+          f === e && (f = null, l.value = null);
+        },
+        setTitle(t) {
+          o !== e && (u.value = !0), o = e, a.value = t;
+        },
+        setTitleInView(t) {
+          o === e && (u.value = t);
+        },
+        clearTitle() {
+          o === e && (o = null, a.value = "", u.value = !0);
+        },
+        setRegistration(t) {
+          n.value = new Map(n.value).set(e, t);
+        },
+        clearRegistration() {
+          if (!n.value.has(e)) return;
+          const t = new Map(n.value);
+          t.delete(e), n.value = t;
+        }
+      };
+    },
+    focusMemory: {
+      take(e) {
+        const t = r.get(e);
+        return r.delete(e), t;
+      },
+      put(e, t) {
+        r.delete(e), r.set(e, t), r.size > y && r.delete(r.keys().next().value ?? "");
+      }
+    }
+  };
+}
+const [g, R] = k("vue-core.pageChrome");
+function P(l) {
+  const a = O();
+  return l.provide(g, a), a;
+}
+function b() {
+  return p() ? w(g, null) : null;
+}
+function S(l) {
+  const u = R().claim();
+  C(
+    () => ({
+      actions: s(l.actions) ?? [],
+      leading: s(l.leading) ?? null,
+      status: s(l.status) ?? null,
+      navTitle: s(l.navTitle) ?? null,
+      documentTitle: s(l.documentTitle) ?? null
+    }),
+    (n) => u.setRegistration(n),
+    { immediate: !0, deep: !0 }
+  ), M(() => u.clearRegistration());
+}
+export {
+  R as a,
+  b,
+  O as c,
+  P as i,
+  g as p,
+  S as u
+};

package/dist/client/client.d.ts

@@ -1,6 +1,7 @@
 import { type QueryValue } from "./encode";
 import { type ApiResult } from "./envelope";
 import { ApiError } from "./error";
+import type { ApiRoute } from "./route";
 import { type Transport } from "./transport";
 export interface RequestOptions {
     query?: Readonly<Record<string, QueryValue>>;
@@ -34,7 +35,18 @@ export interface HttpClientOptions {
      */
     onUnauthorized?: (context: UnauthorizedContext) => UnauthorizedDecision | Promise<UnauthorizedDecision>;
 }
+/** A route that takes no input (`void`, or an empty object) needs no second argument. */
+type RequestArguments<In> = [In] extends [void] ? [input?: undefined, options?: RequestOptions] : [In] extends [Record<string, never>] ? [input?: In, options?: RequestOptions] : [input: In, options?: RequestOptions];
+/** A route declared `void` has no body: its data is `null`. */
+export type RouteResult<Out> = ApiResult<[Out] extends [void] ? null : Out>;
 export interface HttpClient {
+    /**
+     * Calls a declared route: `:name` segments of the path are filled from `input` (encoded), the rest of
+     * `input` is the query for GET and DELETE and the JSON body for POST, PUT and PATCH. A missing path
+     * parameter rejects with a plain `Error` (a bug in the caller, not an answer from the server) before
+     * anything is sent. Abort, request ids and 401 handling are those of `get` and `post`.
+     */
+    request<In, Out>(route: ApiRoute<In, Out>, ...args: RequestArguments<In>): Promise<RouteResult<Out>>;
     get<TData = unknown, TMeta = unknown>(path: string, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
     post<TData = unknown, TMeta = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
     put<TData = unknown, TMeta = unknown>(path: string, body?: unknown, options?: RequestOptions): Promise<ApiResult<TData, TMeta>>;
@@ -43,3 +55,4 @@ export interface HttpClient {
 }
 /** A client over a transport. Nothing is global: every call of this factory is independent. */
 export declare function createHttpClient(options?: HttpClientOptions): HttpClient;
+export {};

package/dist/client/index.d.ts

@@ -1,5 +1,5 @@
 export { createHttpClient } from "./client";
-export type { HttpClient, HttpClientOptions, RequestOptions, UnauthorizedContext, UnauthorizedDecision } from "./client";
+export type { HttpClient, RouteResult, HttpClientOptions, RequestOptions, UnauthorizedContext, UnauthorizedDecision } from "./client";
 export type { QueryValue } from "./encode";
 export { REQUEST_ID_HEADER } from "./envelope";
 export type { ApiResult } from "./envelope";
@@ -7,3 +7,5 @@ export { ApiError, isAborted, isApiError } from "./error";
 export type { ApiErrorInit, ApiErrorKind, FieldErrors } from "./error";
 export { fetchTransport } from "./transport";
 export type { Transport } from "./transport";
+export { route } from "./route";
+export type { HttpMethod, ListResult, RawRoute, ApiRoute, RouteOptions, ViewCount } from "./route";

package/dist/client/index.js

@@ -1,140 +1,21 @@
-import { A as p, k as U, i as b } from "../error-Bb_dr_Ay.js";
-import { a as Q } from "../error-Bb_dr_Ay.js";
-function $(t) {
-  if (!t) return "";
-  const e = new URLSearchParams();
-  for (const [n, r] of Object.entries(t))
-    if (!(r == null || r === ""))
-      if (Array.isArray(r)) for (const i of r) e.append(n, String(i));
-      else e.append(n, String(r));
-  return e.toString();
-}
-const h = (t) => typeof Blob < "u" && t instanceof Blob;
-function D(t) {
-  const e = new FormData();
-  for (const [n, r] of Object.entries(t))
-    if (r != null)
-      if (Array.isArray(r))
-        for (const i of r) e.append(`${n}[]`, T(i));
-      else
-        e.append(n, T(r));
-  return e;
-}
-function T(t) {
-  return h(t) ? t : t instanceof Date ? t.toISOString() : typeof t == "object" && t !== null ? JSON.stringify(t) : String(t);
-}
-function O(t) {
-  if (t === void 0) return { body: void 0, contentType: null };
-  if (typeof t == "string" || t instanceof FormData || t instanceof URLSearchParams || t instanceof ArrayBuffer || ArrayBuffer.isView(t) || h(t))
-    return { body: t, contentType: null };
-  if (typeof t == "object" && t !== null && !Array.isArray(t)) {
-    const e = t;
-    if (Object.values(e).some((n) => h(n) || Array.isArray(n) && n.some(h)))
-      return { body: D(e), contentType: null };
-  }
-  return { body: JSON.stringify(t), contentType: "application/json" };
-}
-function q() {
-  const t = new Uint8Array(16);
-  return globalThis.crypto.getRandomValues(t), Array.from(t, (e) => e.toString(16).padStart(2, "0")).join("");
-}
-const g = "X-Request-ID", A = (t) => typeof t == "object" && t !== null && !Array.isArray(t), m = (t) => typeof t == "string" && t !== "" ? t : null;
-function B(t) {
-  const e = t?.errors ?? t?.fields;
-  if (!A(e)) return {};
-  const n = {};
-  for (const [r, i] of Object.entries(e))
-    Array.isArray(i) ? n[r] = i.map(String) : i != null && (n[r] = [String(i)]);
-  return n;
-}
-async function z(t) {
-  const e = await t.text();
-  if (e.trim() === "") return { payload: null, readable: !0 };
-  try {
-    return { payload: JSON.parse(e), readable: !0 };
-  } catch {
-    return { payload: null, readable: !1 };
-  }
-}
-async function x(t, e) {
-  const n = t.headers.get(g) ?? e, { payload: r, readable: i } = await z(t), o = A(r) ? r : null;
-  if (!t.ok) {
-    const a = B(o), s = o?.params;
-    throw new p({
-      kind: U(t.status, Object.keys(a).length > 0),
-      message: m(o?.error) ?? m(o?.message) ?? `Request failed with status ${t.status}`,
-      status: t.status,
-      fields: a,
-      code: m(o?.code),
-      params: A(s) ? s : null,
-      requestId: n,
-      payload: r
-    });
-  }
-  if (!i)
-    throw new p({
-      kind: "malformed",
-      message: `The server answered ${t.status} with a body that is not JSON`,
-      status: t.status,
-      requestId: n
-    });
-  return o !== null && typeof o.success == "boolean" ? {
-    data: o.data ?? null,
-    meta: o.meta ?? null,
-    message: m(o.message),
-    status: t.status,
-    requestId: n
-  } : { data: r, meta: null, message: null, status: t.status, requestId: n };
-}
-const F = (t, e) => globalThis.fetch(t, e), H = (t) => /^[a-z][a-z0-9+.-]*:\/\//i.test(t);
-function P(t, e, n) {
-  const r = H(e) || t === "" ? e : `${t.replace(/\/+$/, "")}/${e.replace(/^\/+/, "")}`;
-  return n === "" ? r : `${r}${r.includes("?") ? "&" : "?"}${n}`;
-}
-const S = (t, e) => new p({ kind: "aborted", message: "The request was cancelled", requestId: t, cause: e });
-function J(t = {}) {
-  const { baseUrl: e = "", transport: n = F, credentials: r = "include" } = t;
-  async function i(a, s, u, d) {
-    const { signal: f } = d, l = t.requestId === !1 ? null : (t.requestId ?? q)();
-    if (f?.aborted) throw S(l, f.reason);
-    const w = O(u), y = new Headers({ Accept: "application/json" }), E = t.headers ? await t.headers() : void 0;
-    for (const c of [E, d.headers])
-      c && new Headers(c).forEach((I, R) => y.set(R, I));
-    l !== null && !y.has(g) && y.set(g, l), w.contentType !== null && !y.has("Content-Type") && y.set("Content-Type", w.contentType);
-    const j = { method: a, headers: y, credentials: r, body: w.body, signal: f }, k = P(e, s, $(d.query));
-    try {
-      const c = await n(k, j);
-      return await x(c, l);
-    } catch (c) {
-      throw b(c) ? c : f?.aborted || c instanceof Error && c.name === "AbortError" ? S(l, c) : new p({
-        kind: "network",
-        message: c instanceof Error ? c.message : "The server could not be reached",
-        requestId: l,
-        cause: c
-      });
-    }
-  }
-  async function o(a, s, u, d = {}) {
-    try {
-      return await i(a, s, u, d);
-    } catch (f) {
-      if (!b(f) || f.kind !== "unauthorized" || d.handleUnauthorized === !1 || !t.onUnauthorized || await t.onUnauthorized({ error: f, method: a, path: s }) !== "retry") throw f;
-      return i(a, s, u, d);
-    }
-  }
-  return {
-    get: (a, s) => o("GET", a, void 0, s),
-    post: (a, s, u) => o("POST", a, s, u),
-    put: (a, s, u) => o("PUT", a, s, u),
-    patch: (a, s, u) => o("PATCH", a, s, u),
-    delete: (a, s) => o("DELETE", a, void 0, s)
-  };
-}
+import { R as p, c as o, f as u } from "../client-Bw0aM5Gu.js";
+import { A as n, i as f, a as l } from "../error-CD7x0Jrz.js";
+function s(e, i, r = {}) {
+  return { method: e, path: i, permission: r.permission, public: r.public === !0, raw: !1 };
+}
+s.raw = (e, i, r = {}) => ({
+  method: e,
+  path: i,
+  permission: r.permission,
+  public: r.public === !0,
+  raw: !0
+});
 export {
-  p as ApiError,
-  g as REQUEST_ID_HEADER,
-  J as createHttpClient,
-  F as fetchTransport,
-  Q as isAborted,
-  b as isApiError
+  n as ApiError,
+  p as REQUEST_ID_HEADER,
+  o as createHttpClient,
+  u as fetchTransport,
+  f as isAborted,
+  l as isApiError,
+  s as route
 };

package/dist/client/route.d.ts

@@ -0,0 +1,59 @@
+declare const types: unique symbol;
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+export interface RouteOptions {
+    /** The permission the route needs (`"tickets.ticket:view"`); the server enforces it, the client can read it for links and menus. */
+    readonly permission?: string;
+    /** True for routes that need no session. */
+    readonly public?: boolean;
+}
+interface RouteBase {
+    readonly method: HttpMethod;
+    /** Versioned and relative to the client's `baseUrl`; `:name` segments are filled from the input. */
+    readonly path: string;
+    readonly permission?: string;
+    readonly public: boolean;
+}
+/** A typed call: `In` is what `client.request` takes, `Out` what it resolves to (`void`: no body). */
+export interface ApiRoute<In, Out> extends RouteBase {
+    readonly raw: false;
+    /** Type-only; never set. */
+    readonly [types]?: {
+        readonly in: In;
+        readonly out: Out;
+    };
+}
+/** A route without a JSON answer (an event stream, a file): it keeps method and path for links, `client.request` refuses it. */
+export interface RawRoute extends RouteBase {
+    readonly raw: true;
+}
+/**
+ * Declares one endpoint. go-core's generator writes these; the types come from the Go input and response.
+ *
+ *   route<ShowInput, Ticket>("GET", "/v1/tickets/:id", { permission: "tickets.ticket:view" })
+ */
+export declare function route<In, Out>(method: HttpMethod, path: string, options?: RouteOptions): ApiRoute<In, Out>;
+export declare namespace route {
+    var raw: (method: HttpMethod, path: string, options?: RouteOptions) => RawRoute;
+}
+/** One tab's count in `meta.views` (go-core `datatable.ViewCount`). */
+export interface ViewCount {
+    readonly key: string;
+    readonly count: number;
+}
+/**
+ * The wire shape of go-core's `datatable.DatatableResult[T]`: a page of rows with its numbers.
+ * `readListPage` (`/collection`) reads it into a `ListPage` with no glue.
+ */
+export interface ListResult<Row> {
+    readonly data: readonly Row[];
+    readonly meta?: Readonly<Record<string, unknown>> & {
+        readonly views?: readonly ViewCount[];
+    };
+    readonly total: number;
+    readonly per_page: number;
+    readonly current_page: number;
+    readonly last_page: number;
+    readonly from: number;
+    readonly to: number;
+}
+export {};

package/dist/client-Bw0aM5Gu.js

@@ -0,0 +1,147 @@
+import { A, k as I, a as S } from "./error-CD7x0Jrz.js";
+function U(t) {
+  if (!t) return "";
+  const e = new URLSearchParams();
+  for (const [a, r] of Object.entries(t))
+    if (!(r == null || r === ""))
+      if (Array.isArray(r)) for (const i of r) e.append(a, String(i));
+      else e.append(a, String(r));
+  return e.toString();
+}
+const g = (t) => typeof Blob < "u" && t instanceof Blob;
+function D(t) {
+  const e = new FormData();
+  for (const [a, r] of Object.entries(t))
+    if (r != null)
+      if (Array.isArray(r))
+        for (const i of r) e.append(`${a}[]`, E(i));
+      else
+        e.append(a, E(r));
+  return e;
+}
+function E(t) {
+  return g(t) ? t : t instanceof Date ? t.toISOString() : typeof t == "object" && t !== null ? JSON.stringify(t) : String(t);
+}
+function z(t) {
+  if (t === void 0) return { body: void 0, contentType: null };
+  if (typeof t == "string" || t instanceof FormData || t instanceof URLSearchParams || t instanceof ArrayBuffer || ArrayBuffer.isView(t) || g(t))
+    return { body: t, contentType: null };
+  if (typeof t == "object" && t !== null && !Array.isArray(t)) {
+    const e = t;
+    if (Object.values(e).some((a) => g(a) || Array.isArray(a) && a.some(g)))
+      return { body: D(e), contentType: null };
+  }
+  return { body: JSON.stringify(t), contentType: "application/json" };
+}
+function v() {
+  const t = new Uint8Array(16);
+  return globalThis.crypto.getRandomValues(t), Array.from(t, (e) => e.toString(16).padStart(2, "0")).join("");
+}
+const b = "X-Request-ID", T = (t) => typeof t == "object" && t !== null && !Array.isArray(t), w = (t) => typeof t == "string" && t !== "" ? t : null;
+function B(t) {
+  const e = t?.errors ?? t?.fields;
+  if (!T(e)) return {};
+  const a = {};
+  for (const [r, i] of Object.entries(e))
+    Array.isArray(i) ? a[r] = i.map(String) : i != null && (a[r] = [String(i)]);
+  return a;
+}
+async function O(t) {
+  const e = await t.text();
+  if (e.trim() === "") return { payload: null, readable: !0 };
+  try {
+    return { payload: JSON.parse(e), readable: !0 };
+  } catch {
+    return { payload: null, readable: !1 };
+  }
+}
+async function C(t, e) {
+  const a = t.headers.get(b) ?? e, { payload: r, readable: i } = await O(t), o = T(r) ? r : null;
+  if (!t.ok) {
+    const m = B(o), n = o?.params;
+    throw new A({
+      kind: I(t.status, Object.keys(m).length > 0),
+      message: w(o?.error) ?? w(o?.message) ?? `Request failed with status ${t.status}`,
+      status: t.status,
+      fields: m,
+      code: w(o?.code),
+      params: T(n) ? n : null,
+      requestId: a,
+      payload: r
+    });
+  }
+  if (!i)
+    throw new A({
+      kind: "malformed",
+      message: `The server answered ${t.status} with a body that is not JSON`,
+      status: t.status,
+      requestId: a
+    });
+  return o !== null && typeof o.success == "boolean" ? {
+    data: o.data ?? null,
+    meta: o.meta ?? null,
+    message: w(o.message),
+    status: t.status,
+    requestId: a
+  } : { data: r, meta: null, message: null, status: t.status, requestId: a };
+}
+const F = (t, e) => globalThis.fetch(t, e), H = (t) => /^[a-z][a-z0-9+.-]*:\/\//i.test(t);
+function P(t, e, a) {
+  const r = H(e) || t === "" ? e : `${t.replace(/\/+$/, "")}/${e.replace(/^\/+/, "")}`;
+  return a === "" ? r : `${r}${r.includes("?") ? "&" : "?"}${a}`;
+}
+const j = (t, e) => new A({ kind: "aborted", message: "The request was cancelled", requestId: t, cause: e });
+function x(t = {}) {
+  const { baseUrl: e = "", transport: a = F, credentials: r = "include" } = t;
+  async function i(n, s, c, u) {
+    const { signal: f } = u, y = t.requestId === !1 ? null : (t.requestId ?? v)();
+    if (f?.aborted) throw j(y, f.reason);
+    const p = z(c), l = new Headers({ Accept: "application/json" }), h = t.headers ? await t.headers() : void 0;
+    for (const d of [h, u.headers])
+      d && new Headers(d).forEach(($, q) => l.set(q, $));
+    y !== null && !l.has(b) && l.set(b, y), p.contentType !== null && !l.has("Content-Type") && l.set("Content-Type", p.contentType);
+    const k = { method: n, headers: l, credentials: r, body: p.body, signal: f }, R = P(e, s, U(u.query));
+    try {
+      const d = await a(R, k);
+      return await C(d, y);
+    } catch (d) {
+      throw S(d) ? d : f?.aborted || d instanceof Error && d.name === "AbortError" ? j(y, d) : new A({
+        kind: "network",
+        message: d instanceof Error ? d.message : "The server could not be reached",
+        requestId: y,
+        cause: d
+      });
+    }
+  }
+  async function o(n, s, c, u = {}) {
+    try {
+      return await i(n, s, c, u);
+    } catch (f) {
+      if (!S(f) || f.kind !== "unauthorized" || u.handleUnauthorized === !1 || !t.onUnauthorized || await t.onUnauthorized({ error: f, method: n, path: s }) !== "retry") throw f;
+      return i(n, s, c, u);
+    }
+  }
+  async function m(n, s, c = {}) {
+    const u = typeof s == "object" && s !== null && !Array.isArray(s) ? { ...s } : {}, f = n.path.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (p, l) => {
+      const h = u[l];
+      if (h == null || h === "")
+        throw new Error(`${n.method} ${n.path}: the input has no value for the path parameter "${l}"`);
+      return delete u[l], encodeURIComponent(String(h));
+    }), y = Object.keys(u).length > 0;
+    return n.method === "GET" || n.method === "DELETE" ? o(n.method, f, void 0, { ...c, query: { ...u, ...c.query } }) : o(n.method, f, y ? u : void 0, c);
+  }
+  return {
+    // the rest-tuple overload is the public contract; the implementation takes its arguments positionally
+    request: m,
+    get: (n, s) => o("GET", n, void 0, s),
+    post: (n, s, c) => o("POST", n, s, c),
+    put: (n, s, c) => o("PUT", n, s, c),
+    patch: (n, s, c) => o("PATCH", n, s, c),
+    delete: (n, s) => o("DELETE", n, void 0, s)
+  };
+}
+export {
+  b as R,
+  x as c,
+  F as f
+};

package/dist/closeOverlays-CjVsIrpL.js

@@ -0,0 +1,8 @@
+const e = "vue-core:close-overlays";
+function c() {
+  document.dispatchEvent(new Event(e));
+}
+export {
+  e as C,
+  c
+};

package/dist/collection/http.d.ts

@@ -1,4 +1,4 @@
-import type { ApiResult, HttpClient, QueryValue } from "../client";
+import type { ApiResult, HttpClient, ListResult, QueryValue } from "../client";
 import type { CollectionLoader, ListPage, CollectionQuery } from "./types";
 /**
  * The query parameters go-core's datatable reads: `page`, `per_page`, `order_col`, `order_dir`,
@@ -8,9 +8,11 @@ export declare function listParams(query: CollectionQuery): Record<string, Query
 /**
  * Reads a list answer into a `ListPage`. Understands go-core's envelope (`data` is the rows,
  * `meta` has `total`, `page`, `per_page`, `last_page`, `from`, `to`, and may carry `views` and lookups)
- * and ARV's older shape with the numbers next to `data` (`current_page`). Missing numbers are derived
+ * and the shape with the numbers next to `data` (`current_page`), which is `ListResult<Row>`: pass a typed
+ * route's result (`client.request(route, input)`) and `Row` is inferred. Missing numbers are derived
  * from what is there rather than becoming 0; `query` supplies the page and size that were asked for.
  */
+export declare function readListPage<Row>(result: ApiResult<ListResult<Row>, unknown>, query: Pick<CollectionQuery, "page" | "pageSize">): ListPage<Row>;
 export declare function readListPage<Row>(result: ApiResult<unknown, unknown>, query: Pick<CollectionQuery, "page" | "pageSize">): ListPage<Row>;
 /**
  * The loader of a go-core list endpoint: the common case of a feature's `api.list`.