@query-farm/vgi 0.37.1 → 0.39.0

package/src/client/client.ts

@@ -40,6 +40,9 @@ import {
   decodeMacroInfo,
   type MacroType,
   type CatalogAttachResult,
+  type SchemaContentsInfo,
+  decodeIndexInfo,
+  type IndexInfo,
   type AttachOpaqueData,
   type TransactionOpaqueData,
   decodeCatalogInfo,
@@ -54,6 +57,7 @@ import { VgiClientError, wrapRpcWithErrorEnrichment } from "./errors.js";
 import { normalizeSchemaPath } from "../schema-path.js";
 import { encodeASD } from "../codec/asd.js";
 import { ClientCapabilitiesSchema, MacroCreateRequestSchema } from "../generated/vgi-protocol-schemas.js";
+import { decodeCatalogContentsResponse } from "../generated/vgi-protocol-types.js";
 import { deserializeInfoList, deserializeTags, toAsyncIterator } from "./helpers.js";
 
 export { VgiClientError };
@@ -69,6 +73,8 @@ import type {
   OrderByPushdown,
   TablesamplePushdown,
   AttachOptionValue,
+  CatalogSnapshot,
+  LoadCatalogOptions,
 } from "./types.js";
 
 /**
@@ -678,6 +684,185 @@ export class VgiClient {
       global_function_prefix: inner.global_function_prefix ?? "",
       resolved_data_version: inner.resolved_data_version ?? null,
       resolved_implementation_version: inner.resolved_implementation_version ?? null,
+      supports_catalog_contents: inner.supports_catalog_contents ?? false,
+    };
+  }
+
+  /**
+   * Load the whole catalog in one `catalog_contents` call: every schema (parents
+   * before children) with all of its tables, views, functions, macros and
+   * indexes. Only call it when the attach result set
+   * `supports_catalog_contents`; it is the committed catalog at
+   * `catalog_version` (no transaction).
+   *
+   * Pass the `etag` of a snapshot you hold as `ifNoneMatch`: when it is still
+   * current the worker answers `not_modified` with no schemas. `etag` null
+   * means the worker does not revalidate. Each schema's wire `path` is checked
+   * against its decoded `SchemaInfo.path`.
+   *
+   * This is the raw RPC. To enumerate a catalog, use `loadCatalog`, which
+   * checks the capability, revalidates and falls back to the per-schema RPCs.
+   */
+  async catalogContents(
+    attachOpaqueData: AttachOpaqueData,
+    ifNoneMatch: string | null = null,
+  ): Promise<{ catalog_version: number; etag: string | null; not_modified: boolean; schemas: SchemaContentsInfo[] }> {
+    const result = await this.rpc.call("catalog_contents", {
+      attach_opaque_data: attachOpaqueData,
+      if_none_match: ifNoneMatch,
+    });
+    if (!result) throw new VgiClientError("catalog_contents returned null");
+    const response = decodeCatalogContentsResponse(toUint8Array(result.result));
+    const schemas = response.schemas.map((c) => {
+      const schema = decodeSchemaInfo(c.schema);
+      if (JSON.stringify(c.path) !== JSON.stringify(schema.path)) {
+        throw new VgiClientError(
+          `catalog_contents: SchemaContents.path ${JSON.stringify(c.path)} != SchemaInfo.path ${JSON.stringify(schema.path)}`,
+        );
+      }
+      return {
+        schema,
+        tables: c.tables.map(decodeTableInfo),
+        views: c.views.map(decodeViewInfo),
+        scalar_functions: c.scalar_functions.map(decodeFunctionInfo),
+        aggregate_functions: c.aggregate_functions.map(decodeFunctionInfo),
+        table_functions: c.table_functions.map(decodeFunctionInfo),
+        scalar_macros: c.scalar_macros.map(decodeMacroInfo),
+        table_macros: c.table_macros.map(decodeMacroInfo),
+        indexes: c.indexes.map(decodeIndexInfo),
+      };
+    });
+    return {
+      catalog_version: Number(response.catalog_version ?? 0),
+      etag: response.etag ?? null,
+      not_modified: Boolean(response.not_modified),
+      schemas,
+    };
+  }
+
+  /**
+   * Enumerate the whole catalog: every schema with all of its tables, views,
+   * scalar/aggregate/table functions, scalar/table macros and indexes.
+   *
+   * Honors the attach result's `supports_catalog_contents` the way the DuckDB
+   * extension does:
+   *
+   * - advertised (and `useCatalogContents` not false, no transaction): one
+   *   `catalog_contents` call. With `previous.etag` it is conditional
+   *   (`if_none_match`); `not_modified` returns `previous`'s contents.
+   * - not advertised: `catalog_schemas` + per-schema
+   *   `catalog_schema_contents_*` calls -- `catalog_contents` is never sent.
+   *   Kinds whose `estimated_object_count` is exactly 0 are skipped.
+   * - advertised but the call fails (or answers malformed, e.g. a
+   *   `SchemaContents.path` that disagrees with its `SchemaInfo.path`): falls
+   *   back to the per-schema calls and reports the failure in
+   *   `fallback_error`.
+   *
+   * A full answer older than `previous` (a lagging replica) is retried once,
+   * then the per-schema path is used.
+   */
+  async loadCatalog(
+    attach: Pick<CatalogAttachResult, "attach_opaque_data" | "supports_catalog_contents">,
+    opts?: LoadCatalogOptions,
+  ): Promise<CatalogSnapshot> {
+    const attachOpaqueData = attach.attach_opaque_data;
+    const previous = opts?.previous ?? null;
+    const useContents =
+      attach.supports_catalog_contents === true &&
+      opts?.useCatalogContents !== false &&
+      opts?.transactionOpaqueData == null;
+    if (!useContents) {
+      return this._loadCatalogPerSchema(attachOpaqueData, opts?.transactionOpaqueData, null);
+    }
+
+    let fallbackError: string | null = null;
+    const ifNoneMatch = previous?.etag ?? null;
+    const knownVersion = previous?.catalog_version ?? 0;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      let response: Awaited<ReturnType<VgiClient["catalogContents"]>>;
+      try {
+        response = await this.catalogContents(attachOpaqueData, ifNoneMatch);
+      } catch (err) {
+        fallbackError = err instanceof Error ? err.message : String(err);
+        break;
+      }
+      if (response.not_modified) {
+        if (previous == null || ifNoneMatch == null) {
+          fallbackError = "catalog_contents answered not_modified to an unconditional request";
+          break;
+        }
+        return {
+          ...previous,
+          // 0 = unknown: keep the version already known.
+          catalog_version: response.catalog_version !== 0 ? response.catalog_version : previous.catalog_version,
+          etag: response.etag ?? ifNoneMatch,
+          not_modified: true,
+          fallback_error: null,
+        };
+      }
+      // Version adoption: a snapshot at least as new as the known version is
+      // current; 0 means unknown and is accepted. An older one is retried once.
+      if (response.catalog_version !== 0 && knownVersion !== 0 && response.catalog_version < knownVersion) {
+        fallbackError = `catalog_contents snapshot version ${response.catalog_version} is older than the known version ${knownVersion}`;
+        continue;
+      }
+      return {
+        catalog_version: response.catalog_version,
+        etag: response.etag,
+        source: "catalog_contents",
+        not_modified: false,
+        fallback_error: null,
+        schemas: response.schemas,
+      };
+    }
+    return this._loadCatalogPerSchema(attachOpaqueData, undefined, fallbackError);
+  }
+
+  /** `loadCatalog` without `catalog_contents`: catalog_schemas + per-schema calls. */
+  private async _loadCatalogPerSchema(
+    attachOpaqueData: AttachOpaqueData,
+    transactionOpaqueData: TransactionOpaqueData | undefined,
+    fallbackError: string | null,
+  ): Promise<CatalogSnapshot> {
+    const schemas = await this.schemas(attachOpaqueData, transactionOpaqueData);
+    const out: SchemaContentsInfo[] = [];
+    // Sequential on purpose: a stdio RpcClient carries one call at a time.
+    for (const schema of schemas) {
+      const counts = schema.estimated_object_count ?? {};
+      const path = schema.path;
+      // Only an explicit 0 is a guarantee; a missing count is unknown. Decoded
+      // int64 counts are numbers, or bigints beyond the safe range, so compare
+      // numerically.
+      const has = (kind: string) => {
+        const n = (counts as Record<string, unknown>)[kind];
+        return n == null || Number(n) !== 0;
+      };
+      const t = transactionOpaqueData;
+      out.push({
+        schema,
+        tables: has("table") ? await this.schemaContentsTables(attachOpaqueData, path, t) : [],
+        views: has("view") ? await this.schemaContentsViews(attachOpaqueData, path, t) : [],
+        scalar_functions: has("scalar_function")
+          ? await this.schemaContentsFunctions(attachOpaqueData, path, "SCALAR_FUNCTION", t)
+          : [],
+        aggregate_functions: has("aggregate_function")
+          ? await this.schemaContentsFunctions(attachOpaqueData, path, "AGGREGATE_FUNCTION", t)
+          : [],
+        table_functions: has("table_function")
+          ? await this.schemaContentsFunctions(attachOpaqueData, path, "TABLE_FUNCTION", t)
+          : [],
+        scalar_macros: has("macro") ? await this.schemaContentsMacros(attachOpaqueData, path, "SCALAR_MACRO", t) : [],
+        table_macros: has("macro") ? await this.schemaContentsMacros(attachOpaqueData, path, "TABLE_MACRO", t) : [],
+        indexes: has("index") ? await this.schemaContentsIndexes(attachOpaqueData, path, t) : [],
+      });
+    }
+    return {
+      catalog_version: null,
+      etag: null,
+      source: "per_schema",
+      not_modified: false,
+      fallback_error: fallbackError,
+      schemas: out,
     };
   }
 
@@ -902,6 +1087,22 @@ export class VgiClient {
     return deserializeInfoList(inner.items, decodeFunctionInfo);
   }
 
+  /** List indexes in a schema. */
+  async schemaContentsIndexes(
+    attachOpaqueData: AttachOpaqueData,
+    path: string[] | string,
+    transactionOpaqueData?: TransactionOpaqueData,
+  ): Promise<IndexInfo[]> {
+    const result = await this.rpc.call("catalog_schema_contents_indexes", {
+      attach_opaque_data: attachOpaqueData,
+      path: normalizeSchemaPath(path),
+      transaction_opaque_data: transactionOpaqueData ?? null,
+    });
+    if (!result) return [];
+    const inner = unwrapResult(result);
+    return deserializeInfoList(inner.items, decodeIndexInfo);
+  }
+
   /** Get a table by name, or null if not found. */
   async tableGet(
     attachOpaqueData: AttachOpaqueData,

package/src/client/types.ts

@@ -5,6 +5,7 @@ import type { VgiBatch } from "../arrow/index.js";
 import type { Arguments } from "../arguments/arguments.js";
 import type { AttachOptionValue } from "../catalog/attach-options.js";
 import type { BindResponse } from "../protocol/types.js";
+import type { SchemaContentsInfo, TransactionOpaqueData } from "../catalog/interface.js";
 import { OrderByDirection, OrderByNullOrder } from "../protocol/types.js";
 
 export type { AttachOptionValue };
@@ -56,7 +57,7 @@ export interface CatalogAttachOptions {
 export type OnCreateConflict = "error" | "ignore" | "replace";
 
 /** DuckDB catalog function type filter (sent as uppercase wire values). */
-export type CatalogFunctionType = "SCALAR_FUNCTION" | "TABLE_FUNCTION";
+export type CatalogFunctionType = "SCALAR_FUNCTION" | "AGGREGATE_FUNCTION" | "TABLE_FUNCTION";
 
 /** Macro type filter for schema contents listing (uppercase wire values). */
 export type CatalogMacroType = "SCALAR_MACRO" | "TABLE_MACRO";
@@ -151,3 +152,59 @@ export interface TableInOutFunctionOptions {
    */
   hasFinalize?: boolean;
 }
+
+/**
+ * A whole-catalog snapshot returned by `VgiClient.loadCatalog`: every schema
+ * with all of its tables, views, functions, macros and indexes.
+ *
+ * Hold on to it and pass it back as `LoadCatalogOptions.previous` to
+ * revalidate: when it carries an `etag` the client sends that as
+ * `if_none_match`, and a `not_modified` answer returns this snapshot's
+ * contents unchanged.
+ */
+export interface CatalogSnapshot {
+  /**
+   * Version the snapshot was taken at, as reported by `catalog_contents`.
+   * `null` when it was assembled from the per-schema RPCs (which carry no
+   * version); 0 means the worker does not track versions.
+   */
+  catalog_version: number | null;
+  /** Validator to revalidate with; null = the worker does not revalidate. */
+  etag: string | null;
+  /**
+   * How the contents were obtained: one `catalog_contents` call, or
+   * `catalog_schemas` + per-schema `catalog_schema_contents_*` calls.
+   */
+  source: "catalog_contents" | "per_schema";
+  /** True when this load was a `not_modified` revalidation of `previous`. */
+  not_modified: boolean;
+  /**
+   * Set when the catalog advertised `catalog_contents` but the call failed
+   * (or returned a malformed answer) and the client fell back to the
+   * per-schema RPCs: the failure's message.
+   */
+  fallback_error: string | null;
+  /** One entry per schema, parents before children. */
+  schemas: SchemaContentsInfo[];
+}
+
+/** Options for `VgiClient.loadCatalog`. */
+export interface LoadCatalogOptions {
+  /**
+   * A snapshot from an earlier load of the same attach. Its `etag` (if any)
+   * is sent as `if_none_match`; a `not_modified` answer keeps its contents.
+   */
+  previous?: CatalogSnapshot | null;
+  /**
+   * Set false to never call `catalog_contents` (the client-side equivalent of
+   * DuckDB's `SET vgi_catalog_contents = false`). Default true: it is used
+   * whenever the attach result advertised `supports_catalog_contents`.
+   */
+  useCatalogContents?: boolean;
+  /**
+   * Enumerate inside this transaction. `catalog_contents` returns only the
+   * committed catalog (it takes no transaction), so a transaction-scoped load
+   * always uses the per-schema RPCs.
+   */
+  transactionOpaqueData?: TransactionOpaqueData;
+}

package/src/codec/asd.ts

@@ -40,7 +40,102 @@ export function encodeASD(
   schema: VgiSchema,
   obj: Record<string, any>,
 ): Uint8Array {
-  return serializeBatch(batchFromRows([obj], schema));
+  return serializeBatch(batchFromRows([sortMapsForSchema(schema, obj)], schema));
+}
+
+// --------------------------------------------------------------------------- //
+// Encode side: deterministic map columns
+// --------------------------------------------------------------------------- //
+//
+// A map value arrives as a JS object (or Map / pair list), whose iteration
+// order is insertion order -- except that integer-like keys ("1", "2") always
+// come first, ascending. Two builds of the same record could therefore encode
+// differently (and a catalog_contents content-hash etag would change with no
+// catalog change). Every map is written in sorted key order instead, matching
+// the Go / Java / C# / Rust SDKs: keys compared by Unicode code point (the
+// same order as comparing their UTF-8 bytes), not by UTF-16 code unit.
+
+/** Compare two strings by Unicode code point (= UTF-8 byte order). */
+export function compareCodePoints(a: string, b: string): number {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    const x = a.charCodeAt(i);
+    const y = b.charCodeAt(i);
+    if (x === y) continue;
+    // A surrogate (a code point above U+FFFF) sorts after every BMP code unit,
+    // though as a code unit (0xD800-0xDFFF) it sorts below U+E000-U+FFFF.
+    const xs = x >= 0xd800 && x <= 0xdfff;
+    const ys = y >= 0xd800 && y <= 0xdfff;
+    if (xs !== ys) return xs ? 1 : -1;
+    return x - y;
+  }
+  return a.length - b.length;
+}
+
+function mapPairs(raw: any): Array<[unknown, unknown]> {
+  if (Array.isArray(raw)) return raw.map((e: any) => (Array.isArray(e) ? [e[0], e[1]] : [e?.key, e?.value]));
+  if (raw instanceof Map) return Array.from(raw.entries());
+  if (typeof raw[Symbol.iterator] === "function") return Array.from(raw as Iterable<[unknown, unknown]>);
+  return Object.entries(raw);
+}
+
+function compareKeys(a: unknown, b: unknown): number {
+  if (typeof a === "string" && typeof b === "string") return compareCodePoints(a, b);
+  if ((typeof a === "number" || typeof a === "bigint") && (typeof b === "number" || typeof b === "bigint")) {
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  return compareCodePoints(String(a), String(b));
+}
+
+/** Whether a type contains a map anywhere (memoized per type object). */
+const HAS_MAP = new WeakMap<object, boolean>();
+function typeHasMap(type: VgiDataType): boolean {
+  const cached = HAS_MAP.get(type as object);
+  if (cached !== undefined) return cached;
+  let has = isMap(type);
+  if (!has && (isList(type) || isStruct(type))) {
+    has = ((type as any).children as VgiField[]).some((c) => typeHasMap(c.type));
+  }
+  HAS_MAP.set(type as object, has);
+  return has;
+}
+
+function sortMapsForType(type: VgiDataType, value: any): any {
+  if (value == null || !typeHasMap(type)) return value;
+  if (isMap(type)) {
+    const entries = (type as any).children[0].type as VgiDataType;
+    const valueType = ((entries as any).children as VgiField[])[1].type;
+    return mapPairs(value)
+      .map(([k, v]): [unknown, unknown] => [k, sortMapsForType(valueType, v)])
+      .sort((x, y) => compareKeys(x[0], y[0]));
+  }
+  if (isList(type)) {
+    const child = (type as any).children[0].type as VgiDataType;
+    return Array.from(value as Iterable<unknown>, (v) => sortMapsForType(child, v));
+  }
+  if (isStruct(type)) {
+    const out: Record<string, any> = { ...value };
+    for (const cf of (type as any).children as VgiField[]) out[cf.name] = sortMapsForType(cf.type, value[cf.name]);
+    return out;
+  }
+  return value;
+}
+
+/**
+ * `obj` with every map-typed field (at any depth) as a key-sorted pair list.
+ * Returns `obj` itself when the schema has no map column. Never mutates `obj`
+ * (catalog items may be frozen and shared).
+ */
+export function sortMapsForSchema(schema: VgiSchema, obj: Record<string, any>): Record<string, any> {
+  let out: Record<string, any> | null = null;
+  for (const f of schema.fields) {
+    if (!typeHasMap(f.type)) continue;
+    const v = obj[f.name];
+    if (v == null) continue;
+    out ??= { ...obj };
+    out[f.name] = sortMapsForType(f.type, v);
+  }
+  return out ?? obj;
 }
 
 /**
@@ -80,23 +175,27 @@ function normalizeValue(raw: any, type: VgiDataType): any {
   }
 
   if (isMap(type)) {
-    const out: Record<string, string> = {};
+    // Values are decoded with the map's declared value type, like list items
+    // and struct children: a map<utf8, int64> yields numbers (bigint beyond
+    // the safe range), not strings, and a null value stays null.
+    const entries = (type as any).children[0].type as VgiDataType;
+    const valueType = ((entries as any).children as VgiField[])[1].type;
+    const out: Record<string, any> = {};
+    const put = (k: unknown, v: unknown): void => {
+      out[String(k)] = normalizeValue(v, valueType);
+    };
     // arrow-js MapRow is iterable of [k,v]; flechette returns [[k,v],...] arrays.
     if (raw[Symbol.iterator]) {
       for (const entry of raw) {
         if (Array.isArray(entry)) {
-          out[String(entry[0])] = String(entry[1] ?? "");
+          put(entry[0], entry[1]);
         } else if (entry && typeof entry === "object") {
-          const k = entry.key ?? entry[0];
-          const v = entry.value ?? entry[1];
-          out[String(k)] = v == null ? "" : String(v);
+          put(entry.key ?? entry[0], entry.value ?? entry[1]);
         }
       }
     } else if (typeof raw === "object") {
       // Plain-object map (flechette without useMap): Object.entries fallback
-      for (const [k, v] of Object.entries(raw)) {
-        out[String(k)] = v == null ? "" : String(v);
-      }
+      for (const [k, v] of Object.entries(raw)) put(k, v);
     }
     return out;
   }

package/src/functions/copy-to.ts

@@ -75,7 +75,7 @@ export interface CopyToOption {
    * Optional allowed value set, validated worker-side at bind. Mirrors
    * vgi-python's `Arg(..., choices=[...])`.
    */
-  choices?: unknown[];
+  choices?: readonly unknown[];
   /**
    * Optional inclusive lower bound for numeric options, validated worker-side at
    * bind. Mirrors vgi-python's `Arg(..., ge=...)`.

package/src/generated/vgi-client.ts

@@ -2,7 +2,7 @@
 // GENERATED by vgi.codegen.ts_client. DO NOT EDIT BY HAND.
 //
 // Generator: vgi-gen-ts-client v1
-// Content hash: 69731fc31f09
+// Content hash: 5cf87195498c
 //
 // To regenerate:
 //   uv run --project ~/Development/vgi-python vgi-gen-ts-client \
@@ -423,12 +423,33 @@ export interface CatalogAttachResult {
   global_function_prefix: string;
   resolved_data_version?: string | null;
   resolved_implementation_version?: string | null;
+  supports_catalog_contents: boolean;
 }
 
 export interface CatalogsResponse {
   items: CatalogInfo[];
 }
 
+export interface SchemaContents {
+  path: string[];
+  schema: Uint8Array;
+  tables: Uint8Array[];
+  views: Uint8Array[];
+  scalar_functions: Uint8Array[];
+  aggregate_functions: Uint8Array[];
+  table_functions: Uint8Array[];
+  scalar_macros: Uint8Array[];
+  table_macros: Uint8Array[];
+  indexes: Uint8Array[];
+}
+
+export interface CatalogContentsResponse {
+  catalog_version: number;
+  etag?: string | null;
+  not_modified: boolean;
+  schemas: SchemaContents[];
+}
+
 export interface CopyFromFormatsResponse {
   items: Uint8Array[];
 }

package/src/generated/vgi-protocol-schemas.ts

@@ -2,7 +2,7 @@
 // GENERATED by vgi.codegen.ts_schemas. DO NOT EDIT BY HAND.
 //
 // Generator: vgi-gen-ts-schemas v2
-// Content hash: 668f198950df
+// Content hash: 36a9087555c9
 //
 // To regenerate:
 //   uv run --project ~/Development/vgi-python vgi-gen-ts-schemas \
@@ -228,6 +228,20 @@ export const ForeignKeyInfoSchema = schema([
   field("referenced_schema_path", list(field("item", utf8(), true)), false),
 ]);
 
+// Origin: SchemaContents
+export const SchemaContentsSchema = schema([
+  field("path", list(field("item", utf8(), true)), false),
+  field("schema", binary(), false),
+  field("tables", list(field("item", binary(), true)), false),
+  field("views", list(field("item", binary(), true)), false),
+  field("scalar_functions", list(field("item", binary(), true)), false),
+  field("aggregate_functions", list(field("item", binary(), true)), false),
+  field("table_functions", list(field("item", binary(), true)), false),
+  field("scalar_macros", list(field("item", binary(), true)), false),
+  field("table_macros", list(field("item", binary(), true)), false),
+  field("indexes", list(field("item", binary(), true)), false),
+]);
+
 // Origin: AggregateBindRequest
 export const AggregateBindRequestSchema = schema([
   field("function_name", utf8(), false),
@@ -638,6 +652,7 @@ export const CatalogAttachResultSchema = schema([
   field("global_function_prefix", utf8(), false),
   field("resolved_data_version", utf8(), true),
   field("resolved_implementation_version", utf8(), true),
+  field("supports_catalog_contents", bool(), false),
 ]);
 
 // Origin: method 'catalog_catalogs' result
@@ -645,6 +660,14 @@ export const CatalogCatalogsResultSchema = schema([
   field("items", list(field("item", binary(), true)), false),
 ]);
 
+// Origin: method 'catalog_contents' result
+export const CatalogContentsResultSchema = schema([
+  field("catalog_version", int64(), false),
+  field("etag", utf8(), true),
+  field("not_modified", bool(), false),
+  field("schemas", list(field("item", struct([field("path", list(field("item", utf8(), true)), false), field("schema", binary(), false), field("tables", list(field("item", binary(), true)), false), field("views", list(field("item", binary(), true)), false), field("scalar_functions", list(field("item", binary(), true)), false), field("aggregate_functions", list(field("item", binary(), true)), false), field("table_functions", list(field("item", binary(), true)), false), field("scalar_macros", list(field("item", binary(), true)), false), field("table_macros", list(field("item", binary(), true)), false), field("indexes", list(field("item", binary(), true)), false)]), true)), false),
+]);
+
 // Origin: method 'catalog_copy_from_formats' result
 export const CatalogCopyFromFormatsResultSchema = schema([
   field("items", list(field("item", binary(), true)), false),
@@ -833,6 +856,12 @@ export const CatalogAttachParamsSchema = schema([
 // Origin: method 'catalog_catalogs' params
 export const CatalogCatalogsParamsSchema = schema([]);
 
+// Origin: method 'catalog_contents' params
+export const CatalogContentsParamsSchema = schema([
+  field("attach_opaque_data", binary(), false),
+  field("if_none_match", utf8(), true),
+]);
+
 // Origin: method 'catalog_copy_from_formats' params
 export const CatalogCopyFromFormatsParamsSchema = schema([
   field("attach_opaque_data", binary(), false),