bazis 0.96.1

package/library/http-client/HttpClientFactory.ts

@@ -0,0 +1,45 @@
+import { HttpClient } from "./HttpClient";
+import { HttpClientConfigError } from "./errors";
+import type { RequestConfig } from "./types";
+
+/** Resolves pre-configured named clients (à la .NET `IHttpClientFactory`). */
+export interface HttpClientFactory {
+  createClient(name?: string): HttpClient;
+}
+
+/**
+ * Fluent builder for {@link HttpClientFactory}. Unknown names fail fast with
+ * {@link HttpClientConfigError} rather than silently returning a blank client.
+ */
+export class HttpClientFactoryBuilder {
+  private readonly named = new Map<string, RequestConfig>();
+  private defaults: RequestConfig = {};
+
+  /** Config for `createClient()` (no name). */
+  public useDefault(config: RequestConfig): this {
+    this.defaults = config;
+    return this;
+  }
+
+  public addClient(name: string, config: RequestConfig): this {
+    this.named.set(name, config);
+    return this;
+  }
+
+  public build(): HttpClientFactory {
+    const named = new Map(this.named);
+    const defaults = this.defaults;
+    return {
+      createClient(name?: string): HttpClient {
+        if (name === undefined) {
+          return new HttpClient(defaults);
+        }
+        const config = named.get(name);
+        if (config === undefined) {
+          throw new HttpClientConfigError(name, [...named.keys()]);
+        }
+        return new HttpClient(defaults).create(config);
+      },
+    };
+  }
+}

package/library/http-client/errors.ts

@@ -0,0 +1,68 @@
+import type { HttpResponse, RequestConfig } from "./types";
+
+/** Stable error codes (axios-compatible names where applicable). */
+export const HttpErrorCode = {
+  /** Caller aborted via `signal`. */
+  Canceled: "ERR_CANCELED",
+  /** Request exceeded `timeoutMs`. */
+  Timeout: "ETIMEDOUT",
+  /** Transport failure (DNS, connection reset, CORS, …). */
+  Network: "ERR_NETWORK",
+  /** `validateStatus` rejected the response status. */
+  BadStatus: "ERR_BAD_STATUS",
+  /** An accepted response could not be decoded as JSON. */
+  BadResponse: "ERR_BAD_RESPONSE",
+  /** Response body exceeded `maxResponseBytes`. */
+  ResponseTooLarge: "ERR_RESPONSE_TOO_LARGE",
+  /** A redirect chain exceeded `maxRedirects`. */
+  TooManyRedirects: "ERR_TOO_MANY_REDIRECTS",
+  /** The transport hides a redirect or does not acknowledge its protocol. */
+  RedirectNotInspectable: "ERR_REDIRECT_NOT_INSPECTABLE",
+  /** A redirect cannot safely replay its request body. */
+  RedirectBodyNotReplayable: "ERR_REDIRECT_BODY_NOT_REPLAYABLE",
+} as const;
+
+export type HttpErrorCode = (typeof HttpErrorCode)[keyof typeof HttpErrorCode];
+
+/**
+ * axios-style error: carries the originating {@link RequestConfig}, a stable
+ * {@link code}, and (for status failures) the full {@link HttpResponse}.
+ */
+export class HttpClientError<T = unknown> extends Error {
+  public readonly config?: RequestConfig;
+  public readonly code?: HttpErrorCode;
+  public readonly status?: number;
+  public readonly response?: HttpResponse<T>;
+
+  public constructor(
+    message: string,
+    options: {
+      readonly config?: RequestConfig;
+      readonly code?: HttpErrorCode;
+      readonly status?: number;
+      readonly response?: HttpResponse<T>;
+      readonly cause?: unknown;
+    } = {},
+  ) {
+    super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
+    this.name = "HttpClientError";
+    this.config = options.config;
+    this.code = options.code;
+    this.status = options.status ?? options.response?.status;
+    this.response = options.response;
+  }
+
+  /** True when the error represents a non-2xx (or `validateStatus`-rejected) response. */
+  public get isStatusError(): boolean {
+    return this.code === HttpErrorCode.BadStatus;
+  }
+}
+
+/** Thrown when a named client is requested but was never registered. */
+export class HttpClientConfigError extends Error {
+  public constructor(name: string, known: readonly string[]) {
+    const hint = known.length > 0 ? `known clients: ${known.join(", ")}` : "no named clients registered";
+    super(`HttpClient "${name}" is not configured (${hint})`);
+    this.name = "HttpClientConfigError";
+  }
+}

package/library/http-client/index.ts

@@ -0,0 +1,43 @@
+/**
+ * Bazis HTTP client library — a pure, framework-agnostic, axios-class client
+ * over native `fetch`. Zero dependency on the Bazis core or runtime; works in
+ * Bun, browsers and Node 18+.
+ *
+ * ```ts
+ * import { HttpClient } from "@/library/http-client";
+ *
+ * const api = new HttpClient({ baseUrl: "https://api.example.com", timeoutMs: 5000 });
+ * const { data } = await api.get<User[]>("/users", { params: { page: 2 } });
+ * ```
+ */
+export { HttpClient } from "./HttpClient";
+export { InspectableRedirectProtocol } from "./redirectProtocol";
+export { HttpClientFactoryBuilder, type HttpClientFactory } from "./HttpClientFactory";
+export { HttpClientError, HttpClientConfigError, HttpErrorCode } from "./errors";
+export { InterceptorManager, type FulfilledFn, type RejectedFn } from "./interceptors";
+export {
+  appendQuery,
+  basicAuthHeader,
+  defaultParamsSerializer,
+  isBodyInit,
+  resolveUrl,
+  shouldPropagateCorrelation,
+} from "./serialize";
+export type {
+  BasicAuth,
+  CorrelationPropagation,
+  HeaderBag,
+  HttpMethod,
+  HttpResponse,
+  ParamPrimitive,
+  ParamValue,
+  ProgressEvent,
+  ProgressListener,
+  RequestConfig,
+  RequestParams,
+  RequestTransform,
+  ResolvedRequestConfig,
+  ResponseTransform,
+  ResponseType,
+  RetryOptions,
+} from "./types";

package/library/http-client/interceptors.ts

@@ -0,0 +1,40 @@
+export type FulfilledFn<V> = (value: V) => V | Promise<V>;
+export type RejectedFn = (error: unknown) => unknown;
+
+interface Handler<V> {
+  readonly fulfilled: FulfilledFn<V>;
+  readonly rejected?: RejectedFn;
+}
+
+/**
+ * axios-style interceptor registry. `use` returns an id usable with `eject`.
+ * Request interceptors run last-registered-first; response interceptors run
+ * first-registered-first (matching axios semantics) — ordering is applied by
+ * the client, this class just stores handlers stably.
+ */
+export class InterceptorManager<V> {
+  private readonly handlers = new Map<number, Handler<V>>();
+  private nextId = 0;
+
+  public use(fulfilled: FulfilledFn<V>, rejected?: RejectedFn): number {
+    const id = this.nextId;
+    this.nextId += 1;
+    this.handlers.set(id, rejected !== undefined ? { fulfilled, rejected } : { fulfilled });
+    return id;
+  }
+
+  public eject(id: number): void {
+    this.handlers.delete(id);
+  }
+
+  public clear(): void {
+    this.handlers.clear();
+  }
+
+  /** Registered handlers in insertion order. */
+  public toArray(): readonly Handler<V>[] {
+    return [...this.handlers.values()];
+  }
+}
+
+export type { Handler };

package/library/http-client/progress.ts

@@ -0,0 +1,62 @@
+import type { ProgressListener } from "./types";
+
+/**
+ * Drains `response.body`, reporting download progress, and returns a fresh
+ * {@link Response} backed by the collected bytes (so it can still be decoded by
+ * the usual `responseType` path). No-op when there is no readable body.
+ */
+export async function trackDownload(
+  response: Response,
+  onProgress: ProgressListener,
+  rejectRead?: (error: unknown) => never,
+): Promise<Response> {
+  if (!response.body || response.status === 204 || response.status === 205 || response.status === 304) {
+    return response;
+  }
+  const totalHeader = response.headers.get("content-length");
+  const total = totalHeader !== null && Number.isFinite(Number(totalHeader)) ? Number(totalHeader) : undefined;
+
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let loaded = 0;
+  try {
+    for (;;) {
+      // Only transport reads are normalized; exceptions from onProgress below
+      // remain the caller's errors and still trigger producer cleanup.
+      const { done, value } = await reader.read().catch(rejectRead);
+      if (done) break;
+      if (value) {
+        chunks.push(value);
+        loaded += value.byteLength;
+        onProgress({
+          loaded,
+          total,
+          progress: total !== undefined && total > 0 ? loaded / total : undefined,
+          bytes: value.byteLength,
+        });
+      }
+    }
+  } catch (error) {
+    // Initiate cleanup without awaiting an unbounded producer cancel hook.
+    void reader.cancel(error).catch(() => {});
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+
+  return new Response(concat(chunks, loaded), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers,
+  });
+}
+
+function concat(chunks: readonly Uint8Array[], length: number): Uint8Array<ArrayBuffer> {
+  const merged = new Uint8Array(length);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return merged;
+}

package/library/http-client/redirectProtocol.ts

@@ -0,0 +1,6 @@
+/** Wire contract for explicitly negotiated redirects between Bazis peers. */
+export const InspectableRedirectProtocol = {
+  header: "x-bazis-redirect",
+  statusHeader: "x-bazis-redirect-status",
+  version: "manual-v1",
+} as const;

package/library/http-client/serialize.ts

@@ -0,0 +1,133 @@
+import type { CorrelationPropagation, HeaderBag, RequestParams } from "./types";
+
+const ABSOLUTE_URL = /^[a-z][a-z0-9+.-]*:\/\//i;
+
+/**
+ * Resolves `url` against `baseUrl`, **preserving the base path prefix**.
+ * Unlike raw `new URL(url, base)` (where a leading-slash url discards the
+ * prefix), `baseUrl: "https://api/v1"` + `"/users"` → `…/v1/users`.
+ * Absolute URLs and missing baseUrl pass through.
+ */
+export function resolveUrl(baseUrl: string | undefined, url: string): string {
+  if (!baseUrl || ABSOLUTE_URL.test(url)) {
+    return url;
+  }
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const relative = url.startsWith("/") ? url.slice(1) : url;
+  return new URL(relative, base).toString();
+}
+
+/** Default query serializer: skips nullish, expands arrays to repeated keys. */
+export function defaultParamsSerializer(params: RequestParams): string {
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === undefined) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== null && item !== undefined) {
+          search.append(key, String(item));
+        }
+      }
+    } else {
+      search.append(key, String(value));
+    }
+  }
+  return search.toString();
+}
+
+/** Appends serialized params to a URL, respecting an existing query string. */
+export function appendQuery(
+  url: string,
+  params: RequestParams | undefined,
+  serializer: (params: RequestParams) => string = defaultParamsSerializer,
+): string {
+  if (!params) {
+    return url;
+  }
+  const query = serializer(params);
+  if (!query) {
+    return url;
+  }
+  const fragmentIndex = url.indexOf("#");
+  const address = fragmentIndex < 0 ? url : url.slice(0, fragmentIndex);
+  const fragment = fragmentIndex < 0 ? "" : url.slice(fragmentIndex);
+  return address + (address.includes("?") ? "&" : "?") + query + fragment;
+}
+
+/** True for values that fetch accepts as a raw body (not auto-JSON candidates). */
+export function isBodyInit(value: unknown): boolean {
+  if (typeof value === "string") {
+    return true;
+  }
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    return true;
+  }
+  if (typeof URLSearchParams !== "undefined" && value instanceof URLSearchParams) {
+    return true;
+  }
+  if (typeof FormData !== "undefined" && value instanceof FormData) {
+    return true;
+  }
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    return true;
+  }
+  if (typeof ReadableStream !== "undefined" && value instanceof ReadableStream) {
+    return true;
+  }
+  return false;
+}
+
+/** Builds an HTTP Basic `Authorization` header value (browser/Bun/Node safe). */
+export function basicAuthHeader(username: string, password: string): string {
+  const token = `${username}:${password}`;
+  const env = globalThis as {
+    btoa?: (input: string) => string;
+    Buffer?: { from(data: string, encoding: string): { toString(encoding: string): string } };
+  };
+  const encoded = env.btoa ? env.btoa(token) : env.Buffer ? env.Buffer.from(token, "utf-8").toString("base64") : token;
+  return `Basic ${encoded}`;
+}
+
+/** Lowercase-key merge: later bags win. */
+export function mergeHeaderBags(...bags: (HeaderBag | undefined)[]): HeaderBag {
+  const out: HeaderBag = {};
+  for (const bag of bags) {
+    if (!bag) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(bag)) {
+      out[key.toLowerCase()] = value;
+    }
+  }
+  return out;
+}
+
+/** Whether correlation headers may be sent to the resolved URL under the policy. */
+export function shouldPropagateCorrelation(
+  url: string,
+  policy: CorrelationPropagation,
+  baseUrl: string | undefined,
+): boolean {
+  if (policy === "all") {
+    return true;
+  }
+  let host: string;
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  if (Array.isArray(policy)) {
+    return policy.includes(host);
+  }
+  if (!baseUrl) {
+    return false;
+  }
+  try {
+    return new URL(baseUrl).origin === new URL(url).origin;
+  } catch {
+    return false;
+  }
+}

package/library/http-client/types.ts

@@ -0,0 +1,174 @@
+/**
+ * Pure, framework-agnostic HTTP client types. No dependency on the Bazis core
+ * or runtime — the library works anywhere `fetch` exists (Bun, browsers, Node 18+).
+ */
+
+export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+
+/** How the response body is decoded into {@link HttpResponse.data}. */
+export type ResponseType = "json" | "text" | "arrayBuffer" | "blob" | "stream";
+
+export type ParamPrimitive = string | number | boolean;
+export type ParamValue = ParamPrimitive | null | undefined;
+/** Query parameters; array values expand to repeated keys by default. */
+export type RequestParams = Record<string, ParamValue | readonly ParamValue[]>;
+
+/** Plain header bag; values are sent verbatim (case-insensitive merge). */
+export type HeaderBag = Record<string, string>;
+
+/**
+ * Correlation header propagation policy (security-by-default): controls which
+ * hosts receive headers from {@link RequestConfig.correlationHeaders}.
+ * - `"same-origin"` (default): only the exact `baseUrl` scheme/host/port
+ *   (none without a baseUrl);
+ * - `"all"`: every host (internal-only meshes);
+ * - `string[]`: only the listed hostnames.
+ */
+export type CorrelationPropagation = "same-origin" | "all" | readonly string[];
+
+export interface RetryOptions {
+  /** Extra attempts after the first try (idempotent methods only). Default: 0. */
+  readonly maxRetries?: number;
+  /** Base backoff in ms; grows exponentially per attempt. Default: 100. */
+  readonly backoffMs?: number;
+  /** Response statuses that trigger a retry. Default: 408, 429, 500, 502, 503, 504. */
+  readonly retryOn?: readonly number[];
+}
+
+export interface BasicAuth {
+  readonly username: string;
+  readonly password: string;
+}
+
+/** Download progress event (upload progress is not supported by `fetch`). */
+export interface ProgressEvent {
+  /** Bytes received so far. */
+  readonly loaded: number;
+  /** Total bytes from `Content-Length`, if known. */
+  readonly total?: number;
+  /** Completion ratio `0..1` when {@link total} is known. */
+  readonly progress?: number;
+  /** Bytes in the most recent chunk. */
+  readonly bytes: number;
+}
+
+export type ProgressListener = (event: ProgressEvent) => void;
+
+/** Mutates/replaces the request body before encoding; may mutate `headers`. */
+export type RequestTransform = (data: unknown, headers: HeaderBag) => unknown;
+
+/** Transforms the decoded response data before it is delivered. */
+export type ResponseTransform = (data: unknown, headers: Headers, status: number) => unknown;
+
+/**
+ * Per-request configuration. Mirrors the axios config surface (baseUrl, params,
+ * data, headers, timeout, responseType, validateStatus, auth, withCredentials,
+ * interceptors) plus first-class retries and correlation propagation.
+ */
+export interface RequestConfig {
+  /** Request URL; resolved against {@link baseUrl} (prefix preserved). */
+  url?: string;
+  method?: HttpMethod | string;
+  /** Base URL prefix; absolute `url`s bypass it. */
+  baseUrl?: string;
+  headers?: HeaderBag;
+  /** Query parameters appended to the URL. */
+  params?: RequestParams;
+  /** Custom query serializer; defaults to repeated keys for arrays. */
+  paramsSerializer?: (params: RequestParams) => string;
+  /** Request body. Plain objects are JSON-encoded; `BodyInit` is sent as-is. */
+  data?: unknown;
+  /** Pre-process the request body (applied in order before encoding). */
+  transformRequest?: RequestTransform | readonly RequestTransform[];
+  /** Post-process the decoded response data (applied in order). */
+  transformResponse?: ResponseTransform | readonly ResponseTransform[];
+  /** Download progress callback (reads the body stream to report bytes). */
+  onDownloadProgress?: ProgressListener;
+  /** Non-negative safe integer timeout in ms. Default: 0 (disabled at the library level). */
+  timeoutMs?: number;
+  /** Cap on bytes read after Fetch decoding (including decompression). Non-negative safe integer; `0`/undefined disables it. */
+  maxResponseBytes?: number;
+  /** Caller cancellation signal; combined with the timeout. */
+  signal?: AbortSignal | null;
+  /** Expected response decoding. Default: inferred from `content-type`. */
+  responseType?: ResponseType;
+  /** Sets `credentials: "include"` when true. */
+  withCredentials?: boolean;
+  /** Fine-grained fetch credentials (overrides {@link withCredentials}). */
+  credentials?: RequestInit["credentials"];
+  /** HTTP Basic auth; adds an `Authorization` header. */
+  auth?: BasicAuth;
+  /**
+   * Allow custom/auth/cookie headers on an absolute URL or redirect outside
+   * `baseUrl`'s origin, and allow a redirect to replay a request body there.
+   * Disabled by default to prevent secret exfiltration.
+   */
+  allowCrossOriginCredentials?: boolean;
+  /**
+   * Returns `true` for statuses that resolve (others reject with
+   * {@link HttpClientError}). Default: `status >= 200 && status < 300`.
+   * Pass `null` to never reject on status.
+   */
+  validateStatus?: ((status: number) => boolean) | null;
+  /** Resilience policy for idempotent requests. */
+  retry?: RetryOptions;
+  /** Correlation header propagation policy. Default: `"same-origin"`. */
+  propagateCorrelation?: CorrelationPropagation;
+  /** Supplies correlation headers (e.g. from a runtime context). */
+  correlationHeaders?: () => HeaderBag;
+  /** Custom fetch implementation (testing / instrumentation). */
+  fetch?: typeof fetch;
+  /**
+   * Negotiate inspectable redirects with an Bazis HTTP server that has the
+   * same option enabled. Default: false. Applies only to redirect: "follow".
+   * Enforces maxRedirects exactly (0–100), including in browsers. Successful
+   * responses must acknowledge the protocol; CORS, origin and body replay rules
+   * still apply. Disables HTTP caching for this explicitly negotiated mode.
+   */
+  inspectableRedirects?: boolean;
+  /**
+   * Redirect behavior. Bun/Node follow hop-by-hop and strip foreign secrets.
+   * Browsers follow bodyless requests with safe headers; native Fetch strips
+   * Authorization on a foreign redirect and omits foreign cookies. Requests
+   * carrying custom secrets, bodies or credentials: "include" follow only
+   * within the page/worker origin unless allowCrossOriginCredentials is set.
+   * Restricted correlation headers remain guarded. A foreign API can return
+   * an ordinary CORS response without opt-in. Manual redirects are opaque
+   * (status 0). Uninspectable manual hops use ERR_REDIRECT_NOT_INSPECTABLE;
+   * native follow failures use ERR_NETWORK. See inspectableRedirects for the
+   * negotiated alternative with per-hop checks.
+   */
+  redirect?: RequestInit["redirect"];
+  /**
+   * Maximum redirects per attempt. Default: 20; allowed range: 0–100.
+   * Bun/Node enforce the exact cap. Browsers use redirect: "error" for 0 and
+   * their native cap of 20 for budgets >= 20. With 1–19, ordinary responses
+   * work but hidden redirects fail with ERR_REDIRECT_NOT_INSPECTABLE before
+   * following. With inspectableRedirects, the exact cap works in browsers too.
+   * No probe or duplicate request is sent.
+   */
+  maxRedirects?: number;
+  cache?: RequestInit["cache"];
+  mode?: RequestInit["mode"];
+  keepalive?: boolean;
+  /** Arbitrary metadata carried through interceptors (not sent). */
+  meta?: Record<string, unknown>;
+}
+
+/** Config after merging client defaults with the per-request config. */
+export type ResolvedRequestConfig = RequestConfig & { method: string };
+
+/** axios-style response envelope. */
+export interface HttpResponse<T = unknown> {
+  readonly data: T;
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: Headers;
+  readonly config: ResolvedRequestConfig;
+  /**
+   * The original Fetch `Response`, retaining URL/type/redirect metadata.
+   * Its body may be consumed or locked by the response limit/progress reader.
+   * With `responseType: "stream"`, consume or cancel `data` to respect the limit.
+   */
+  readonly raw: Response;
+}

package/library/jsonapi/ListQueryError.ts

@@ -0,0 +1,25 @@
+/** One list-request parsing problem (tied to a specific parameter). */
+export interface ListQueryProblem {
+  /** Query parameter name, for example `sort`, `filter[age]`, `page[size]`. */
+  readonly parameter: string;
+  /** Human-readable description of the problem. */
+  readonly message: string;
+}
+
+/**
+ * List-request parsing/validation error. Collects all problems at once so the
+ * client sees the full list, not just the first one.
+ *
+ * The library deliberately knows nothing about HTTP: the integration layer maps
+ * it to 400 (see the `ListRequest` binding in `@/core/http`).
+ */
+export class ListQueryError extends Error {
+  constructor(readonly problems: readonly ListQueryProblem[]) {
+    super(
+      problems.length > 0
+        ? problems.map((problem) => `${problem.parameter}: ${problem.message}`).join("; ")
+        : "Invalid list query",
+    );
+    this.name = "ListQueryError";
+  }
+}

package/library/jsonapi/ListRequest.ts

@@ -0,0 +1,37 @@
+import type { FilterGroup, FilterRule, ListQuery, PageParams, SortField } from "./types";
+
+const EMPTY_PAGE: PageParams = { number: 1, size: 20, offset: 0, limit: 20 };
+
+/**
+ * Base class of a typed list request. A subclass declares the allowed "request
+ * surface" with field decorators (`@Sortable`, `@Filterable`) and limits
+ * (`@ListOptions`); the kernel recognizes such a controller parameter by its
+ * `ListRequest` base and fills the instance with the parsed
+ * `sort`/`filters`/`page`, **by signature**.
+ *
+ * Implements {@link ListQuery}, so it is passed straight to `paginate(...)`.
+ *
+ * ```ts
+ * @ListOptions({ defaultSize: 20, maxSize: 100 })
+ * class UserListQuery extends ListRequest<User> {
+ *   @Sortable() @Filterable("eq", "contains") name!: string;
+ *   @Sortable() @Filterable("gte", "lte", "in") age!: number;
+ * }
+ *
+ * // controller, by signature:
+ * list(query: UserListQuery) { return this.users.list(query); }
+ * ```
+ *
+ * The type parameter `T` is a phantom entity marker for readability; it is not
+ * used at runtime.
+ */
+export class ListRequest<T = unknown> implements ListQuery {
+  declare readonly __entity?: T;
+
+  sort: readonly SortField[] = [];
+  filters: readonly FilterRule[] = [];
+  or: readonly FilterGroup[] = [];
+  page: PageParams = EMPTY_PAGE;
+  include: readonly string[] = [];
+  fields: Readonly<Record<string, readonly string[]>> = {};
+}