@instruments/materialgraph 0.24.0 → 0.26.0

package/samplize-colorvec.js

@@ -3,43 +3,54 @@ export const SAMPLIZE_COLORVEC_RANKING_VERSION = "solid-colorvec-cosine-v2";
 export const SAMPLIZE_COLORVEC_EMBEDDING_VERSION = EMBEDDING_VERSION;
 const decodeVector = (encoded) => {
     const bytes = Uint8Array.from(atob(encoded), (c) => c.charCodeAt(0));
-    if (bytes.length !== EMBEDDING_VECTOR_SIZE * 4)
+    if (bytes.length !== EMBEDDING_VECTOR_SIZE * 4) {
         throw new Error("Invalid colour vector size.");
+    }
     const view = new DataView(bytes.buffer);
     return Array.from({ length: EMBEDDING_VECTOR_SIZE }, (_, i) => view.getFloat32(i * 4, true));
 };
 const facets = ["brand", "family", "lightness", "intensity"];
 const identityOrder = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 export const samplizeSolidColorVector = (hex) => {
-    if (!/^#[0-9a-f]{6}$/i.test(hex))
+    if (!/^#[0-9a-f]{6}$/i.test(hex)) {
         throw new Error("A six-digit published colour is required.");
+    }
     return paletteToEmbedding([{ hex, proportion: 1 }], { validateOklab: true });
 };
 /** Canonical constraints are shared by full-cache similarity and constrained text retrieval. */
-export function selectSamplizeEligiblePaints(paints, input) {
+export const selectSamplizeEligiblePaints = (paints, input) => {
     const reference = input.reference
         ? paints.find((p) => p.variantId === input.reference)
         : undefined;
-    if (input.reference && !reference)
+    if (input.reference && !reference) {
         throw new Error("The reference is absent from this catalogue version.");
-    const low = input.lightnessMin ?? 0, high = input.lightnessMax ?? 1;
-    const cool = input.temperatureMin ?? -0.4, warm = input.temperatureMax ?? 0.4;
+    }
+    const low = input.lightnessMin ?? 0;
+    const high = input.lightnessMax ?? 1;
+    const cool = input.temperatureMin ?? -0.4;
+    const warm = input.temperatureMax ?? 0.4;
     if (![low, high, cool, warm].every(Number.isFinite) ||
         low > high ||
-        cool > warm)
+        cool > warm) {
         throw new Error("Appearance ranges must be finite and ordered.");
+    }
     const candidates = paints.filter((p) => {
-        if (!reference)
+        if (!reference) {
             return true;
-        if (p.variantId === reference.variantId)
+        }
+        if (p.variantId === reference.variantId) {
             return false;
-        if (input.direction === "lighter")
+        }
+        if (input.direction === "lighter") {
             return p.oklab.L > reference.oklab.L;
-        if (input.direction === "darker")
+        }
+        if (input.direction === "darker") {
             return p.oklab.L < reference.oklab.L;
-        if (input.direction === "muted")
+        }
+        if (input.direction === "muted") {
             return (Math.hypot(p.oklab.a, p.oklab.b) <
                 Math.hypot(reference.oklab.a, reference.oklab.b));
+        }
         return true;
     });
     const matches = (p, omit) => p.oklab.L >= low &&
@@ -50,25 +61,30 @@ export function selectSamplizeEligiblePaints(paints, input) {
     const counts = {
         brand: {},
         family: {},
-        lightness: {},
         intensity: {},
+        lightness: {},
     };
-    for (const p of candidates)
-        for (const f of facets)
-            if (matches(p, f))
+    for (const p of candidates) {
+        for (const f of facets) {
+            if (matches(p, f)) {
                 counts[f][p[f]] = (counts[f][p[f]] ?? 0) + 1;
+            }
+        }
+    }
     const eligible = candidates.filter((p) => matches(p));
-    return { reference, eligible, counts };
-}
+    return { counts, eligible, reference };
+};
 /** Official portable MG ranking over its complete versioned sampling-channel projection. */
-export function createSamplizeColorVecIndex(cache) {
+export const createSamplizeColorVecIndex = (cache) => {
     if (cache.embeddingVersion !== EMBEDDING_VERSION ||
-        cache.rankingVersion !== SAMPLIZE_COLORVEC_RANKING_VERSION)
+        cache.rankingVersion !== SAMPLIZE_COLORVEC_RANKING_VERSION) {
         throw new Error("The colour cache uses an incompatible embedding or ranking version. Refresh it before searching.");
+    }
     if (!cache.sourceVersion ||
         !cache.dictionaryVersion ||
-        !Number.isFinite(Date.parse(cache.generatedAt)))
+        !Number.isFinite(Date.parse(cache.generatedAt))) {
         throw new Error("The colour cache is missing its provenance.");
+    }
     const paints = cache.paints.map((p) => ({
         ...p,
         vector: typeof p.vector === "string" ? decodeVector(p.vector) : p.vector,
@@ -78,8 +94,9 @@ export function createSamplizeColorVecIndex(cache) {
         if (identities.has(paint.variantId) ||
             paint.vector.length !== EMBEDDING_VECTOR_SIZE ||
             !paint.vector.every(Number.isFinite) ||
-            ![paint.oklab.L, paint.oklab.a, paint.oklab.b].every(Number.isFinite))
+            ![paint.oklab.L, paint.oklab.a, paint.oklab.b].every(Number.isFinite)) {
             throw new Error("The colour cache contains invalid or duplicate paint records.");
+        }
         identities.add(paint.variantId);
     }
     const vectors = new Map();
@@ -88,8 +105,9 @@ export function createSamplizeColorVecIndex(cache) {
         let value = vectors.get(key);
         if (!value) {
             value = samplizeSolidColorVector(hex);
-            if (vectors.size >= 512)
+            if (vectors.size >= 512) {
                 vectors.delete(vectors.keys().next().value);
+            }
             vectors.set(key, value);
         }
         return value;
@@ -97,36 +115,42 @@ export function createSamplizeColorVecIndex(cache) {
     return {
         search(input) {
             const limit = input.limit ?? 48;
-            if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+            if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
                 throw new Error("Choose between 1 and 100 suggestions.");
+            }
             const { reference, eligible, counts } = selectSamplizeEligiblePaints(paints, input);
             const palette = (input.palette?.length
                 ? input.palette
                 : [{ hex: input.hex ?? reference?.hex ?? "", proportion: 1 }])
                 .map((p) => ({ ...p, hex: p.hex.toLowerCase() }))
-                .sort((a, b) => b.proportion - a.proportion || identityOrder(a.hex, b.hex));
+                .toSorted((a, b) => b.proportion - a.proportion || identityOrder(a.hex, b.hex));
             if (palette.length > 12 ||
                 palette.some((p) => !Number.isFinite(p.proportion) ||
                     p.proportion <= 0 ||
-                    p.proportion > 1))
+                    p.proportion > 1)) {
                 throw new Error("Supply up to twelve positive image colour shares.");
+            }
             const total = palette.reduce((sum, p) => sum + p.proportion, 0);
             const buckets = palette.map((p, position) => ({
                 ...p,
+                paints: [],
                 position,
-                vector: vectorFor(p.hex),
                 quota: Math.floor((limit * p.proportion) / total),
                 remainder: ((limit * p.proportion) / total) % 1,
-                paints: [],
+                vector: vectorFor(p.hex),
             }));
             let remaining = limit - buckets.reduce((sum, p) => sum + p.quota, 0);
-            for (const p of [...buckets].sort((a, b) => b.remainder - a.remainder || a.position - b.position))
-                if (remaining-- > 0)
+            for (const p of [...buckets].toSorted((a, b) => b.remainder - a.remainder || a.position - b.position)) {
+                if (remaining-- > 0) {
                     p.quota++;
+                }
+            }
             for (const paint of eligible) {
-                let best = buckets[0], score = embeddingCosineSimilarity(paint.vector, best.vector);
+                let best = buckets[0];
+                let score = embeddingCosineSimilarity(paint.vector, best.vector);
                 for (let i = 1; i < buckets.length; i++) {
-                    const candidate = buckets[i], next = embeddingCosineSimilarity(paint.vector, candidate.vector);
+                    const candidate = buckets[i];
+                    const next = embeddingCosineSimilarity(paint.vector, candidate.vector);
                     if (next > score) {
                         best = candidate;
                         score = next;
@@ -135,33 +159,33 @@ export function createSamplizeColorVecIndex(cache) {
                 best.paints.push({ id: paint.variantId, score });
             }
             const groups = buckets
-                .sort((a, b) => b.proportion - a.proportion || a.position - b.position)
+                .toSorted((a, b) => b.proportion - a.proportion || a.position - b.position)
                 .map((p) => {
                 const ids = p.paints
-                    .sort((a, b) => b.score - a.score || identityOrder(a.id, b.id))
+                    .toSorted((a, b) => b.score - a.score || identityOrder(a.id, b.id))
                     .slice(0, p.quota)
                     .map((paint) => paint.id);
                 return {
                     hex: p.hex,
+                    ids,
                     proportion: p.proportion,
                     quota: p.quota,
-                    ids,
                     shortfall: p.quota - ids.length,
                 };
             });
             const ids = groups.flatMap((p) => p.ids);
             return {
-                ids,
-                groups,
-                limited: eligible.length > ids.length,
-                eligibleCount: eligible.length,
+                countBasis: "complete-catalogue",
                 counts,
-                sourceVersion: cache.sourceVersion,
                 dictionaryVersion: cache.dictionaryVersion,
+                eligibleCount: eligible.length,
                 embeddingVersion: cache.embeddingVersion,
+                groups,
+                ids,
+                limited: eligible.length > ids.length,
                 rankingVersion: cache.rankingVersion,
-                countBasis: "complete-catalogue",
+                sourceVersion: cache.sourceVersion,
             };
         },
     };
-}
+};

package/schema-resource-types.d.ts

@@ -8,40 +8,40 @@ export type SchemaResource = "blocks" | "attributes" | "verticals" | "productTyp
  * it must cover cannot drift apart.
  */
 export declare const SCHEMA_RESOURCE_OPERATION_IDS: {
-    readonly blocks: "list_schema_blocks";
     readonly attributes: "list_schema_attributes";
-    readonly verticals: "list_schema_verticals";
+    readonly blocks: "list_schema_blocks";
+    readonly mappings: "list_schema_mappings";
+    readonly productTypeTemplates: "list_schema_product_type_templates";
     readonly productTypes: "list_schema_product_types";
+    readonly sourceRequirements: "list_schema_source_requirements";
     readonly units: "list_schema_units";
     readonly valueDictionaries: "list_schema_value_dictionaries";
-    readonly sourceRequirements: "list_schema_source_requirements";
-    readonly productTypeTemplates: "list_schema_product_type_templates";
-    readonly mappings: "list_schema_mappings";
+    readonly verticals: "list_schema_verticals";
 };
 export type SchemaResourceRequest = SchemaResource;
-export interface SchemaLifecycle {
+export type SchemaLifecycle = {
     status: OpenEnum<"draft" | "active" | "deprecated">;
     introducedIn: string;
     deprecatedIn?: string;
     supersededBy?: string;
-}
-export interface SchemaExternalMapping {
+};
+export type SchemaExternalMapping = {
     target: OpenEnum<"schema_org" | "ifc_pset" | "bsdd" | "iso_23387" | "eclass" | "gs1_gdm" | "gdsn" | "etim" | "uniclass">;
     targetPath: string;
     mappingType: OpenEnum<"direct" | "transform" | "derived" | "classification" | "semantic">;
     notes?: string;
-}
-export interface SchemaBlockItem {
+};
+export type SchemaBlockItem = {
     id: string;
     semanticId: string;
     lifecycle: SchemaLifecycle;
     name: string;
     description: string;
     attributeIds: string[];
-}
+};
 export type KnownSchemaQuantityKind = "length" | "area" | "volume" | "mass" | "time" | "temperature" | "currency" | "ratio" | "density" | "coverage" | "emissions" | "force" | "power" | "voltage" | "current" | "frequency" | "luminous_flux" | "color_temperature" | "count" | "unitless";
 export type SchemaQuantityKind = OpenEnum<KnownSchemaQuantityKind>;
-export interface SchemaAttributeItem {
+export type SchemaAttributeItem = {
     id: string;
     semanticId: string;
     lifecycle: SchemaLifecycle;
@@ -58,14 +58,14 @@ export interface SchemaAttributeItem {
     comparable: boolean;
     usedInBlocks: string[];
     enumValues: string[] | null;
-}
-export interface SchemaVerticalItem {
+};
+export type SchemaVerticalItem = {
     id: string;
     displayName: string;
     description: string;
-}
+};
 export type SchemaApplicability = OpenEnum<"required" | "recommended" | "optional" | "unusual">;
-export interface SchemaProductTypeBlock {
+export type SchemaProductTypeBlock = {
     blockId: string;
     applicability: SchemaApplicability;
     requiredAttributes?: string[];
@@ -74,8 +74,8 @@ export interface SchemaProductTypeBlock {
     completenessWeight?: number;
     notes?: string;
     optional?: boolean;
-}
-export interface SchemaProductTypeItem {
+};
+export type SchemaProductTypeItem = {
     id: string;
     name: string;
     description?: string;
@@ -85,8 +85,8 @@ export interface SchemaProductTypeItem {
     productTypeSpecificAttributes?: string[];
     semanticId: string;
     lifecycle: SchemaLifecycle;
-}
-export interface SchemaUnitItem {
+};
+export type SchemaUnitItem = {
     id: string;
     name: string;
     symbol: string;
@@ -99,8 +99,8 @@ export interface SchemaUnitItem {
     notes?: string;
     semanticId: string;
     lifecycle: SchemaLifecycle;
-}
-export interface SchemaValueDictionaryTerm {
+};
+export type SchemaValueDictionaryTerm = {
     id: string;
     label: string;
     aliases?: string[];
@@ -108,20 +108,20 @@ export interface SchemaValueDictionaryTerm {
     externalMappings?: SchemaExternalMapping[];
     semanticId: string;
     lifecycle: SchemaLifecycle;
-}
-export interface SchemaValueDictionaryItem {
+};
+export type SchemaValueDictionaryItem = {
     id: string;
     name: string;
     description: string;
     terms: SchemaValueDictionaryTerm[];
     semanticId: string;
     lifecycle: SchemaLifecycle;
-}
+};
 export type KnownSchemaSourceType = "manufacturer_page" | "technical_data_sheet" | "safety_data_sheet" | "test_report" | "certificate" | "image" | "commerce_page" | "catalog_pdf" | "derived_analysis";
 export type SchemaSourceType = OpenEnum<KnownSchemaSourceType>;
 export type KnownSchemaSourceMethod = "manual_review" | "agent_extract" | "pdf_extract" | "image_analysis" | "html_scrape" | "structured_feed" | "calculation";
 export type SchemaSourceMethod = OpenEnum<KnownSchemaSourceMethod>;
-export interface SchemaSourceRequirementItem {
+export type SchemaSourceRequirementItem = {
     id: string;
     name: string;
     description: string;
@@ -130,11 +130,11 @@ export interface SchemaSourceRequirementItem {
     minConfidence: number;
     reviewRequired: boolean;
     freshnessDays?: number;
-    sourceBasis?: OpenEnum<"declared" | "derived" | "declared">;
+    sourceBasis?: OpenEnum<"declared" | "derived">;
     semanticId: string;
     lifecycle: SchemaLifecycle;
-}
-export interface SchemaProductTypeTemplateBlock {
+};
+export type SchemaProductTypeTemplateBlock = {
     blockId: string;
     applicability: SchemaApplicability;
     requiredAttributes?: string[];
@@ -142,8 +142,8 @@ export interface SchemaProductTypeTemplateBlock {
     sourceRequirementId?: string;
     completenessWeight?: number;
     notes?: string;
-}
-export interface SchemaProductTypeTemplateItem {
+};
+export type SchemaProductTypeTemplateItem = {
     id: string;
     name: string;
     productTypeId: string;
@@ -152,8 +152,8 @@ export interface SchemaProductTypeTemplateItem {
     notes?: string;
     semanticId: string;
     lifecycle: SchemaLifecycle;
-}
-export interface SchemaMappingItem {
+};
+export type SchemaMappingItem = {
     target: SchemaExternalMapping["target"];
     subjectKind?: OpenEnum<"attribute" | "block" | "product_type" | "template" | "unit" | "value_dictionary" | "value_dictionary_term">;
     subjectId?: string;
@@ -161,8 +161,8 @@ export interface SchemaMappingItem {
     targetPath: string;
     mappingType: SchemaExternalMapping["mappingType"];
     notes?: string;
-}
-export interface SchemaResourceItemMap {
+};
+export type SchemaResourceItemMap = {
     blocks: SchemaBlockItem;
     attributes: SchemaAttributeItem;
     verticals: SchemaVerticalItem;
@@ -172,10 +172,10 @@ export interface SchemaResourceItemMap {
     sourceRequirements: SchemaSourceRequirementItem;
     productTypeTemplates: SchemaProductTypeTemplateItem;
     mappings: SchemaMappingItem;
-}
-export interface SchemaResourceResponse<K extends SchemaResource = SchemaResource> {
+};
+export type SchemaResourceResponse<K extends SchemaResource = SchemaResource> = {
     kind: K;
     schemaVersion: string;
     items: SchemaResourceItemMap[K][];
     totalCount: number;
-}
+};

package/schema-resource-types.js

@@ -5,13 +5,13 @@
  * it must cover cannot drift apart.
  */
 export const SCHEMA_RESOURCE_OPERATION_IDS = {
-    blocks: "list_schema_blocks",
     attributes: "list_schema_attributes",
-    verticals: "list_schema_verticals",
+    blocks: "list_schema_blocks",
+    mappings: "list_schema_mappings",
+    productTypeTemplates: "list_schema_product_type_templates",
     productTypes: "list_schema_product_types",
+    sourceRequirements: "list_schema_source_requirements",
     units: "list_schema_units",
     valueDictionaries: "list_schema_value_dictionaries",
-    sourceRequirements: "list_schema_source_requirements",
-    productTypeTemplates: "list_schema_product_type_templates",
-    mappings: "list_schema_mappings",
+    verticals: "list_schema_verticals",
 };

package/search-card-types.d.ts

@@ -11,14 +11,15 @@
 import type { ProductId, VariantId } from "./identifiers.js";
 import type { OpenEnum, SearchData, SearchResponse } from "./types.js";
 /**
- * The lean `view:"card"` result item — identity + name + thumbnail + score.
+ * The lean `view:"card"` result item — identity + name + code + thumbnail +
+ * score.
  *
  * A PROJECTION, not a smaller answer: a field the card omits (palette, verdict,
  * signals, availability) is unread here, never known-absent. Re-read the same
  * `variantId` at `view: "full"` or via `material()` before claiming anything the
  * card does not carry.
  */
-export interface SearchCardItem {
+export type SearchCardItem = {
     /** Accepted sampleability fact. Absent means unknown, never false. */
     sampleable?: boolean;
     /** Opaque — round-trip verbatim. */
@@ -30,6 +31,14 @@ export interface SearchCardItem {
     name: string;
     variantName: string | null;
     imageUrl: string | null;
+    /**
+     * The manufacturer's own item code, the same key the full item carries.
+     * Reach for it when two cards read alike: `name` is the PRODUCT name, and a
+     * paint product is a whole collection, so brand, product name and variant
+     * name together are shared by most of the catalogue. ABSENT means no code is
+     * recorded, never that the variant cannot be ordered.
+     */
+    manufacturerCode?: string;
     projectSaveCapability?: "allowed";
     sourceStatus?: "provisional";
     score: number;
@@ -45,11 +54,11 @@ export interface SearchCardItem {
      * attribute rather than a list of candidates.
      */
     attributes?: Record<string, string | string[] | null>;
-}
+};
 /** The `view:"card"` response form — the lean grid projection of {@link SearchResponse}. */
-export interface SearchCardResponse extends Omit<SearchResponse, "data"> {
+export type SearchCardResponse = {
     data: Omit<SearchData, "view" | "results"> & {
         view: OpenEnum<"card">;
         results: SearchCardItem[];
     };
-}
+} & Omit<SearchResponse, "data">;

package/search-collapse-types.d.ts

@@ -31,7 +31,7 @@ import type { SearchResultSignals } from "./types.js";
  * engine issues for the card only. Fetch the variant by `variantId` when you
  * need its full record.
  */
-export interface CollapsedVariant {
+export type CollapsedVariant = {
     /** Opaque — round-trip verbatim. */
     variantId: VariantId;
     /** The variant's own label; for paint, the colourway name. Null when unnamed. */
@@ -52,18 +52,18 @@ export interface CollapsedVariant {
     materialBankId?: string;
     /** This variant's own mode-primary score — the value the array is ordered by. */
     score: number;
-}
+};
 /**
  * One member of a collapsed result's `SearchResultItem.anatomy` — the
  * EXPLAIN-only readout of the same grouping {@link CollapsedVariant} publishes.
  * Where a collapsed variant is what a surface renders, this is what an operator
  * inspects: it carries the per-arm `signals` that made the variant a candidate.
  */
-export interface SearchAnatomyMember {
+export type SearchAnatomyMember = {
     /** Opaque — round-trip verbatim. */
     variantId: VariantId;
     variantName: string | null;
     color: string | null;
     score: number;
     signals: SearchResultSignals;
-}
+};

package/search-mood-types.d.ts

@@ -1,6 +1,6 @@
 /** What a standard search did, and did not, recognize as a governed mood. */
-export interface MoodInterpretation {
+export type MoodInterpretation = {
     query: string | null;
     moodId: string | null;
     supersededMoodId: string | null;
-}
+};

package/search-refinement-types.d.ts

@@ -23,7 +23,7 @@ import type { SearchInput } from "./types.js";
  * of this object — without it, "no GREENGUARD results" reads as "nobody is
  * certified" when it means "nobody is certified TO THIS EVIDENTIAL STANDARD".
  */
-export interface SearchFilterTrust {
+export type SearchFilterTrust = {
     /** Confidence floor, 0–1. A value below it is excluded, not marked failed. */
     minConfidence?: number;
     /**
@@ -45,7 +45,7 @@ export interface SearchFilterTrust {
     sourceBasis?: "catalog_feed" | "declared" | "derived";
     /** Fold the attribute's own registry confidence requirement in, server-side. */
     meetsRequirement?: true;
-}
+};
 /**
  * One HARD criterion. Applied as a restriction BEFORE ranking, so a filtered
  * search's empty result means "nothing on record satisfies this", never "nothing
@@ -97,13 +97,13 @@ export type SearchFilter = {
     trust?: SearchFilterTrust;
 };
 /** One structured refinement returned with a search response. */
-export interface SearchSuggestion {
+export type SearchSuggestion = {
     label: string;
     /** Complete replacement request, not a partial patch. */
     request: SearchInput;
-}
+};
 /** One reading a {@link SearchDisambiguation} offers. */
-export interface SearchInterpretation {
+export type SearchInterpretation = {
     id: string;
     label: string;
     kind: string;
@@ -113,7 +113,7 @@ export interface SearchInterpretation {
     hex?: string;
     /** Complete replacement request, not a partial patch. */
     request: SearchInput;
-}
+};
 /** The governed ambiguity classes emitted by MaterialGraph search. */
 export type SearchDisambiguationKind = "compliance-phrase" | "colour-material" | "paint-colour" | "paint-identity";
 /**
@@ -124,10 +124,10 @@ export type SearchDisambiguationKind = "compliance-phrase" | "colour-material" |
  * so choosing a reading is a re-issue rather than a patch. Ignoring this block does not
  * make the ambiguity go away — it makes it invisible to the person who asked.
  */
-export interface SearchDisambiguation {
+export type SearchDisambiguation = {
     /** Compliance, colour-material, paint-colour, or paint-identity ambiguity. */
     kind: SearchDisambiguationKind;
     /** The ambiguous term or phrase. */
     term: string;
     interpretations: SearchInterpretation[];
-}
+};

package/search-request-types.d.ts

@@ -15,9 +15,9 @@ import type { ColourInput, OpenEnum, SearchImageInput } from "./types.js";
  * optional; supply at least one signal (`text`, `colours`, `mood`, `similarTo`,
  * or `image`). Passed through to the server verbatim.
  */
-export interface SearchInput {
+export type SearchInput = {
     text?: string;
-    textModes?: Array<OpenEnum<"visual" | "lexical">>;
+    textModes?: OpenEnum<"visual" | "lexical">[];
     colours?: ColourInput[];
     colourLogic?: OpenEnum<"all" | "any">;
     colourTolerance?: OpenEnum<"tight" | "normal" | "loose">;
@@ -122,7 +122,7 @@ export interface SearchInput {
      * demotes a failed/missing preferred hit WITHIN its page only.
      */
     preferences?: SearchFilter[];
-    /** Page size — the size of ONE page, never a bound on the match set. */
+    /** Results per page (default 60, max 60), never a bound on the match set. */
     limit?: number;
     /** The previous response's `cursor`, passed back verbatim. Never synthesise one. */
     cursor?: Cursor;
@@ -210,9 +210,9 @@ export interface SearchInput {
      * cards, which are orderable samples and never specifiable materials.
      */
     includeSamplingArtifacts?: boolean;
-}
+};
 /** Query-string params for the GET `/search` form. */
-export interface SearchGetParams {
+export type SearchGetParams = {
     q?: string;
     colours?: string;
     logic?: OpenEnum<"all" | "any">;
@@ -242,4 +242,4 @@ export interface SearchGetParams {
     orderBy?: string;
     /** Comma-separated attribute ids — the `returnAttributes` list. */
     returnAttributes?: string;
-}
+};