@instruments/materialgraph 3.0.2 → 3.2.0

package/material-asset-types.d.ts

@@ -20,6 +20,13 @@ export type VariantAssetAvailability = OpenEnum<"available" | "unknown" | "unava
 export type VariantImageRole = OpenEnum<"product" | "swatch" | "detail" | "scene" | "technical" | "color_chart" | "sample_collection" | "other" | "unknown">;
 /** How an image must be framed, a different question from what it shows. */
 export type VariantImagePresentation = OpenEnum<"edge_to_edge" | "packshot" | "cutout_margin" | "montage" | "unknown">;
+/** What a photo shows of its material, so an app can place it at real size. */
+export type VariantImageShows = OpenEnum<"sample" | "crop" | "laid_field" | "room" | "detail">;
+/** The size of the surface in an image's frame, in millimeters. */
+export interface VariantImageSurfaceMm {
+    width_mm: number;
+    height_mm: number;
+}
 /** What a document is for; a document can carry more than one purpose. */
 export type VariantDocumentType = OpenEnum<"technical_data_sheet" | "product_sheet" | "technical_bulletin" | "sustainability_report" | "specification" | "installation_guide" | "care_maintenance_guide" | "operation_manual" | "warranty" | "parts_list" | "technical_drawing" | "test_report" | "certificate" | "declaration_of_performance" | "environmental_product_declaration" | "health_product_declaration" | "ingredient_disclosure" | "safety_data_sheet" | "brochure" | "catalog" | "color_finish_chart" | "other" | "unknown">;
 /** Every asset kind the registry knows. */
@@ -29,7 +36,7 @@ export type VariantAssetKind = OpenEnum<"image" | "document" | "cad" | "bim" | "
  * appear on their kind, and an absent value is unknown. `url` is absent when
  * `availability` is `unavailable`; `appliesTo` appears only as `product`.
  */
-export type VariantAssetItem = {
+export interface VariantAssetItem {
     /** Only `product`: filed against the whole product. Absent: this variant's own. */
     appliesTo?: "product";
     assetId: string;
@@ -43,23 +50,29 @@ export type VariantAssetItem = {
     /** Images only; absent when unknown. */
     imageRole?: VariantImageRole;
     kind: VariantAssetKind;
+    /** Millimeters per pixel of this file. Images only; absent when unknown. */
+    mmPerPx?: number;
     /** Not on images; absent when unknown. */
     name?: string;
     /** Images only; absent when unknown. */
     presentation?: VariantImagePresentation;
+    /** What the photo shows of the material. Images only; absent when unknown. */
+    shows?: VariantImageShows;
+    /** The surface in frame: width and height times `mmPerPx`. Images only; absent when unknown. */
+    surfaceMm?: VariantImageSurfaceMm;
     url?: string;
     /** Images only; absent when unknown. */
     width?: number;
-};
+}
 /** Whether the brand's document source was read for this variant. Absent when documents are filtered out. */
 export type VariantDocumentCoverageState = OpenEnum<"available" | "none_declared" | "not_ingested" | "unavailable_source" | "dead_link" | "failed_ingest">;
-export type VariantAssetPageInfo = {
+export interface VariantAssetPageInfo {
     nextCursor: string | null;
     returnedCount: number;
     totalMatches: number;
-};
+}
 /** Request filters and paging for `listVariantAssets`. Each list is OR within itself, AND across lists. */
-export type ListVariantAssetsOptions = {
+export interface ListVariantAssetsOptions {
     kinds?: VariantAssetKind[];
     imageRoles?: VariantImageRole[];
     documentTypes?: VariantDocumentType[];
@@ -67,28 +80,28 @@ export type ListVariantAssetsOptions = {
     limit?: number;
     /** `pageInfo.nextCursor` from the previous page, with the same variantId and filters. */
     cursor?: string;
-};
+}
 /** One page. An unknown variant is a 404, never a page. */
-export type VariantAssetPage = {
+export interface VariantAssetPage {
     documentCoverage?: VariantDocumentCoverageState;
     items: VariantAssetItem[];
     pageInfo: VariantAssetPageInfo;
     /** The variant's primary image. Absent when it has none. */
     primaryAssetId?: string;
-};
+}
 export type MaterialDocumentStatus = OpenEnum<"downloaded" | "linked_not_downloaded" | "unavailable_source" | "dead_link" | "failed_ingest">;
 export type MaterialDocumentCoverageState = OpenEnum<"available" | "none_declared" | "not_ingested" | "unavailable_source" | "dead_link" | "failed_ingest">;
-export type MaterialDocumentScope = {
+export interface MaterialDocumentScope {
     kind: "product" | "variant";
     id: string;
-};
-export type MaterialDocumentSource = {
+}
+export interface MaterialDocumentSource {
     /** Opaque, public identifier for one source collection; never a PIM/DAM path. */
     id: string;
     authority: string;
     revision: string;
-};
-export type MaterialDocumentProjectionItem = {
+}
+export interface MaterialDocumentProjectionItem {
     id: string;
     scope: MaterialDocumentScope & {
         inherited: boolean;
@@ -113,34 +126,34 @@ export type MaterialDocumentProjectionItem = {
     contentType: string | null;
     fileExtension: string | null;
     source: MaterialDocumentSource;
-};
-export type MaterialDocumentCoverageSource = {
+}
+export interface MaterialDocumentCoverageSource {
     scope: MaterialDocumentScope;
     state: MaterialDocumentCoverageState;
     exact: boolean;
     declaredCount: number | null;
     readableCount: number;
     source: MaterialDocumentSource;
-};
-export type MaterialDocumentCoverage = {
+}
+export interface MaterialDocumentCoverage {
     productUnion: MaterialDocumentCoverageSummary;
     requestedVariant: MaterialDocumentCoverageSummary;
     sources: MaterialDocumentCoverageSource[];
-};
-export type MaterialDocumentCoverageSummary = {
+}
+export interface MaterialDocumentCoverageSummary {
     state: MaterialDocumentCoverageState;
     exact: boolean;
     declaredCount: number | null;
     readableCount: number;
-};
-export type MaterialDocumentPageOptions = {
+}
+export interface MaterialDocumentPageOptions {
     cursor?: string;
     limit?: number;
-};
-export type MaterialDocumentPage = {
+}
+export interface MaterialDocumentPage {
     variantId: VariantId;
     documents: MaterialDocumentProjectionItem[];
     coverage: MaterialDocumentCoverage;
     totalDocuments: number;
     nextCursor: string | null;
-};
+}

package/material-block-types.d.ts

@@ -51,7 +51,7 @@ export type MaterialBlockFieldValue = string | number | boolean | unknown[] | Re
  * `status: "complete"` is a real negative you may publish; the same `false`
  * under `missing` is a placeholder for an unanswered question.
  */
-export type MaterialBlockProjectionField = {
+export interface MaterialBlockProjectionField {
     /** Canonical vocabulary, not an opaque id - the same token `listVariants` filters accept. */
     attributeId: string;
     label: string;
@@ -64,21 +64,21 @@ export type MaterialBlockProjectionField = {
     valueSource?: string;
     /** Claim confidence supplied by the graph; absence means no confidence was emitted. */
     confidence?: number;
-};
-export type MaterialBlockProjectionItem = {
+}
+export interface MaterialBlockProjectionItem {
     canonicalBlockId: string;
     canonicalBlockName: string;
     status: MaterialBlockStatus;
     fields: MaterialBlockProjectionField[];
     /** The work queue: attributes with `status: "missing"`. UNKNOWN, never "none". */
     missingAttributeIds: string[];
-};
+}
 /**
  * Every canonical block for one material, each field carrying whether it is
  * determined. The whole surface, not a page — there is no cursor here.
  */
-export type MaterialBlockProjection = {
+export interface MaterialBlockProjection {
     /** Opaque — echoed from the request. */
     variantId: VariantId;
     blocks: MaterialBlockProjectionItem[];
-};
+}

package/material-types.d.ts

@@ -34,7 +34,7 @@ export type MaterialAvailability = OpenEnum<"available" | "discontinued" | "supe
  * The grid-card projection of a material. Tiles carry `availability` but not a
  * successor record.
  */
-export type MaterialTile = {
+export interface MaterialTile {
     /** Accepted sampleability fact. Absent means unknown, never false. */
     sampleable?: boolean;
     /** Opaque — round-trip verbatim into every other material read. */
@@ -57,9 +57,9 @@ export type MaterialTile = {
      * the attribute is absent — never render a missing key as "unnamed".
      */
     colorName?: string;
-};
+}
 /** A retained product-type proposal. It is review evidence, never a category. */
-type ProposedProductType = {
+interface ProposedProductType {
     id: string;
     displayName: string;
     confidence: number | null;
@@ -67,10 +67,10 @@ type ProposedProductType = {
     sourceUrl: string | null;
     isPrimary: boolean;
     scope: "variant" | "product";
-};
+}
 /** Accepted display categories remain separate from this review-state receipt. */
-export type ProductTypeReceipt = {
+export interface ProductTypeReceipt {
     state: "accepted" | "proposed" | "unknown";
     proposedProductTypes: ProposedProductType[];
-};
+}
 export {};

package/nearest-paints-types.d.ts

@@ -1,10 +1,10 @@
 import type { SearchCatalogSubset } from "./search-catalog-subset-types.js";
-export type NearestPaintsParams = {
+export interface NearestPaintsParams {
     hexes: string[];
     limit?: number;
     searchCatalogSubset?: SearchCatalogSubset;
-};
-export type NearestPaintCard = {
+}
+export interface NearestPaintCard {
     variantId: string;
     name: string;
     brand: {
@@ -25,11 +25,11 @@ export type NearestPaintCard = {
     lrv: number | null;
     deltaE: number;
     closeness: "very-near" | "very-close" | "close" | "related" | "unrelated";
-};
-export type NearestPaintsHexResult = {
+}
+export interface NearestPaintsHexResult {
     hex: string;
     paints: NearestPaintCard[];
-};
-export type NearestPaintsOutput = {
+}
+export interface NearestPaintsOutput {
     results: NearestPaintsHexResult[];
-};
+}

package/operation-responses.d.ts

@@ -20,7 +20,7 @@ import type { SchemaResourceResponse } from "./schema-resource-types.js";
 import type { SearchVariantsOutput } from "./search-variants-types.js";
 import type { SourceMaterialBatchReceipt } from "./source-material-types.js";
 import type { ExtractPaletteResponse, ListAttributesResult, PairingsResponse, ResolveColorResponse, WhoamiResponse } from "./types.js";
-export type OperationResponses = {
+export interface OperationResponses {
     get_discovery_reference: DiscoveryReference;
     interpret_discovery_terms: DiscoveryTerms;
     find_colorless_variants: ColorlessVariantsResult;
@@ -56,5 +56,5 @@ export type OperationResponses = {
     search_variants: SearchVariantsOutput;
     upload_source_material: SourceMaterialBatchReceipt;
     whoami: WhoamiResponse;
-};
+}
 export type JsonOperationId = keyof OperationResponses;

package/operations.d.ts

@@ -1,4 +1,4 @@
-import { type SdkOperation, type SdkOperationId } from "./operations.generated.js";
+import type { SdkOperation, SdkOperationId } from "./operations.generated.js";
 export { MATERIALGRAPH_API_VERSION, SDK_OPERATIONS, } from "./operations.generated.js";
 export type { SdkOperation, SdkOperationId } from "./operations.generated.js";
 /** Look up a registered operation by its OpenAPI `operationId`. */

package/operations.js

@@ -1,5 +1,5 @@
 import { MaterialGraphError } from "./errors.js";
-import { SDK_OPERATIONS, } from "./operations.generated.js";
+import { SDK_OPERATIONS } from "./operations.generated.js";
 export { MATERIALGRAPH_API_VERSION, SDK_OPERATIONS, } from "./operations.generated.js";
 /** Look up a registered operation by its OpenAPI `operationId`. */
 export const findSdkOperation = (operationId) => SDK_OPERATIONS.find((candidate) => candidate.operationId === operationId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instruments/materialgraph",
-  "version": "3.0.2",
+  "version": "3.2.0",
   "type": "module",
   "exports": {
     ".": {

package/parse-operation-response.d.ts

@@ -1,5 +1,6 @@
+import type { JsonValue } from "./json-value-types.js";
+import type { JsonObject } from "./json.js";
 import type { JsonOperationId, OperationResponses } from "./operation-responses.js";
-import type { JsonSchema } from "./response-schemas.js";
 /** Evaluate the JSON Schema keywords used by the published response contracts. */
-export declare const matchesResponseSchema: (value: unknown, schema: unknown, root: JsonSchema) => boolean;
-export declare const parseOperationResponse: <K extends JsonOperationId>(operationId: K, value: unknown) => Promise<OperationResponses[K]>;
+export declare const matchesResponseSchema: (value: JsonValue | undefined, schema: JsonValue | undefined, root: JsonObject) => boolean;
+export declare const parseOperationResponse: <K extends JsonOperationId>(operationId: K, value: JsonValue | undefined) => Promise<OperationResponses[K]>;

package/parse-operation-response.js

@@ -1,185 +1,162 @@
 import { openClientResponseEnums } from "./client-response-schema.js";
 import { MaterialGraphError } from "./errors.js";
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+import { isJsonNumber, isJsonObject, isJsonString, jsonKind } from "./json.js";
 const sameJson = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const SIMPLE_TYPES = new Set([
+    "array",
+    "boolean",
+    "null",
+    "object",
+    "string",
+]);
 const matchesType = (value, type) => {
     if (Array.isArray(type)) {
         return type.some((candidate) => matchesType(value, candidate));
     }
-    switch (type) {
-        case undefined: {
-            return true;
-        }
-        case "null": {
-            return value === null;
-        }
-        case "array": {
-            return Array.isArray(value);
-        }
-        case "object": {
-            return isRecord(value);
-        }
-        case "integer": {
-            return typeof value === "number" && Number.isInteger(value);
-        }
-        case "number": {
-            return typeof value === "number" && Number.isFinite(value);
-        }
-        case "string": {
-            return typeof value === "string";
-        }
-        case "boolean": {
-            return typeof value === "boolean";
-        }
-        default: {
-            return false;
-        }
+    if (type === undefined) {
+        return true;
+    }
+    if (type === "integer") {
+        return isJsonNumber(value) && Number.isInteger(value);
+    }
+    if (type === "number") {
+        return isJsonNumber(value) && Number.isFinite(value);
     }
+    return (isJsonString(type) && SIMPLE_TYPES.has(type) && jsonKind(value) === type);
 };
 const matchesNumberKeywords = (value, schema) => {
-    if (typeof value === "number") {
-        if (typeof schema.minimum === "number" && value < schema.minimum) {
-            return false;
+    if (!isJsonNumber(value)) {
+        return true;
+    }
+    const { exclusiveMaximum, exclusiveMinimum, maximum, minimum } = schema;
+    if (isJsonNumber(minimum) && value < minimum) {
+        return false;
+    }
+    if (isJsonNumber(maximum) && value > maximum) {
+        return false;
+    }
+    if (isJsonNumber(exclusiveMinimum) && value <= exclusiveMinimum) {
+        return false;
+    }
+    return !(isJsonNumber(exclusiveMaximum) && value >= exclusiveMaximum);
+};
+const matchesStringKeywords = (value, schema) => {
+    if (!isJsonString(value)) {
+        return true;
+    }
+    const { maxLength, minLength, pattern } = schema;
+    let length = 0;
+    for (const _codePoint of value) {
+        length += 1;
+    }
+    if (isJsonNumber(minLength) && length < minLength) {
+        return false;
+    }
+    if (isJsonNumber(maxLength) && length > maxLength) {
+        return false;
+    }
+    return !(isJsonString(pattern) && !new RegExp(pattern, "u").test(value));
+};
+const matchesValueKeywords = (value, schema) => {
+    if ("const" in schema && !sameJson(value, schema.const)) {
+        return false;
+    }
+    const { enum: allowed } = schema;
+    return !(Array.isArray(allowed) &&
+        !allowed.some((candidate) => sameJson(candidate, value)));
+};
+/** Evaluates the JSON Schema keywords the published response contracts use. */
+class ResponseSchemaEvaluator {
+    #root;
+    constructor(root) {
+        this.#root = root;
+    }
+    matches(value, schema) {
+        if (schema === true || schema === false) {
+            return schema;
         }
-        if (typeof schema.maximum === "number" && value > schema.maximum) {
+        if (!isJsonObject(schema)) {
             return false;
         }
-        if (typeof schema.exclusiveMinimum === "number" &&
-            value <= schema.exclusiveMinimum) {
+        if (!this.#matchesReference(value, schema)) {
             return false;
         }
-        if (typeof schema.exclusiveMaximum === "number" &&
-            value >= schema.exclusiveMaximum) {
+        if (!matchesType(value, schema.type)) {
             return false;
         }
-    }
-    return true;
-};
-const matchesStringKeywords = (value, schema) => {
-    if (typeof value === "string") {
-        let length = 0;
-        for (const _codePoint of value) {
-            length += 1;
-        }
-        if (typeof schema.minLength === "number" && length < schema.minLength) {
+        if (!matchesValueKeywords(value, schema)) {
             return false;
         }
-        if (typeof schema.maxLength === "number" && length > schema.maxLength) {
+        if (Array.isArray(schema.anyOf) &&
+            !schema.anyOf.some((candidate) => this.matches(value, candidate))) {
             return false;
         }
-        if (typeof schema.pattern === "string" &&
-            !new RegExp(schema.pattern, "u").test(value)) {
+        if ("not" in schema && this.matches(value, schema.not)) {
             return false;
         }
+        return (matchesNumberKeywords(value, schema) &&
+            matchesStringKeywords(value, schema) &&
+            this.#matchesArrayKeywords(value, schema) &&
+            this.#matchesObjectKeywords(value, schema));
     }
-    return true;
-};
-const matchesArrayKeywords = (value, schema, root) => {
-    if (Array.isArray(value)) {
-        if (typeof schema.minItems === "number" && value.length < schema.minItems) {
+    #matchesArrayKeywords(value, schema) {
+        if (!Array.isArray(value)) {
+            return true;
+        }
+        const { items, maxItems, minItems, prefixItems } = schema;
+        if (isJsonNumber(minItems) && value.length < minItems) {
             return false;
         }
-        if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
+        if (isJsonNumber(maxItems) && value.length > maxItems) {
             return false;
         }
-        const prefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : [];
+        const prefix = Array.isArray(prefixItems) ? prefixItems : [];
         for (const [index, item] of value.entries()) {
-            const itemSchema = index < prefix.length ? prefix[index] : schema.items;
-            if (itemSchema !== undefined &&
-                !matchesResponseSchema(item, itemSchema, root)) {
+            const itemSchema = index < prefix.length ? prefix[index] : items;
+            if (itemSchema !== undefined && !this.matches(item, itemSchema)) {
                 return false;
             }
         }
+        return true;
     }
-    return true;
-};
-const matchesObjectKeywords = (value, schema, root) => {
-    if (isRecord(value)) {
-        if (Array.isArray(schema.required) &&
-            !schema.required.every((key) => typeof key === "string" && Object.hasOwn(value, key))) {
+    #matchesObjectKeywords(value, schema) {
+        if (!isJsonObject(value)) {
+            return true;
+        }
+        const { additionalProperties, propertyNames, required } = schema;
+        if (Array.isArray(required) &&
+            !required.every((key) => isJsonString(key) && Object.hasOwn(value, key))) {
             return false;
         }
-        const properties = isRecord(schema.properties) ? schema.properties : {};
+        const properties = isJsonObject(schema.properties) ? schema.properties : {};
         for (const [key, item] of Object.entries(value)) {
-            if (schema.propertyNames !== undefined &&
-                !matchesResponseSchema(key, schema.propertyNames, root)) {
+            if (propertyNames !== undefined && !this.matches(key, propertyNames)) {
                 return false;
             }
             const property = Object.hasOwn(properties, key)
                 ? properties[key]
-                : schema.additionalProperties;
-            if (property !== undefined &&
-                !matchesResponseSchema(item, property, root)) {
+                : additionalProperties;
+            if (property !== undefined && !this.matches(item, property)) {
                 return false;
             }
         }
+        return true;
     }
-    return true;
-};
-const matchesResponseReference = (value, schema, root) => {
-    if (typeof schema.$ref === "string") {
-        if (!schema.$ref.startsWith("#/$defs/")) {
-            return false;
+    #matchesReference(value, schema) {
+        const reference = schema.$ref;
+        if (!isJsonString(reference)) {
+            return true;
         }
-        const name = schema.$ref
-            .slice(8)
-            .replaceAll("~1", "/")
-            .replaceAll("~0", "~");
-        if (!isRecord(root.$defs) ||
-            !matchesResponseSchema(value, root.$defs[name], root)) {
+        if (!reference.startsWith("#/$defs/")) {
             return false;
         }
+        const name = reference.slice(8).replaceAll("~1", "/").replaceAll("~0", "~");
+        const definitions = this.#root.$defs;
+        return isJsonObject(definitions) && this.matches(value, definitions[name]);
     }
-    return true;
-};
-const matchesResponseValue = (value, schema) => {
-    if ("const" in schema && !sameJson(value, schema.const)) {
-        return false;
-    }
-    if (Array.isArray(schema.enum) &&
-        !schema.enum.some((candidate) => sameJson(candidate, value))) {
-        return false;
-    }
-    return true;
-};
+}
 /** Evaluate the JSON Schema keywords used by the published response contracts. */
-export const matchesResponseSchema = (value, schema, root) => {
-    if (typeof schema === "boolean") {
-        return schema;
-    }
-    if (!isRecord(schema)) {
-        return false;
-    }
-    if (!matchesResponseReference(value, schema, root)) {
-        return false;
-    }
-    if (!matchesType(value, schema.type)) {
-        return false;
-    }
-    if (!matchesResponseValue(value, schema)) {
-        return false;
-    }
-    if (Array.isArray(schema.anyOf) &&
-        !schema.anyOf.some((candidate) => matchesResponseSchema(value, candidate, root))) {
-        return false;
-    }
-    if ("not" in schema && matchesResponseSchema(value, schema.not, root)) {
-        return false;
-    }
-    if (!matchesNumberKeywords(value, schema)) {
-        return false;
-    }
-    if (!matchesStringKeywords(value, schema)) {
-        return false;
-    }
-    if (!matchesArrayKeywords(value, schema, root)) {
-        return false;
-    }
-    if (!matchesObjectKeywords(value, schema, root)) {
-        return false;
-    }
-    return true;
-};
+export const matchesResponseSchema = (value, schema, root) => new ResponseSchemaEvaluator(root).matches(value, schema);
 const schemas = new Map();
 /** The operation's published schema, rather than a caller's type argument, proves its response. */
 const isOperationResponse = (operationId, value) => {
@@ -190,8 +167,8 @@ export const parseOperationResponse = async (operationId, value) => {
     let schema = schemas.get(operationId);
     if (!schema) {
         // oxlint-disable-next-line howells/no-runtime-dynamic-imports -- Load the large response schema bundle only when a response needs validation.
-        const { responseSchema } = await import("./response-schemas.js");
-        schema = responseSchema(operationId);
+        const catalog = await import("./response-schema-catalog.js");
+        schema = catalog.buildResponseSchema(operationId);
         openClientResponseEnums(schema);
         schemas.set(operationId, schema);
     }

package/resolve-color-types.d.ts

@@ -7,15 +7,15 @@ import type { VariantId } from "./identifiers.js";
 import type { SearchCatalogSubset } from "./search-catalog-subset-types.js";
 import type { OpenEnum } from "./types.js";
 /** Options for `resolveColor`. */
-export type ResolveColorOptions = {
+export interface ResolveColorOptions {
     /**
      * Sets `inScope` on each catalog variant the lookup reports. It never
      * narrows the lookup. Absent leaves every `inScope` null.
      */
     searchCatalogSubset?: SearchCatalogSubset;
-};
+}
 /** One catalog variant carrying the named paint. */
-export type ResolveColorCatalogVariant = {
+export interface ResolveColorCatalogVariant {
     variantId: VariantId;
     /** The brand exactly as stored, suspect or not. */
     brand: {
@@ -25,7 +25,7 @@ export type ResolveColorCatalogVariant = {
     };
     /** Whether the variant is in the requested scope; null when none was asked for. */
     inScope: boolean | null;
-};
+}
 /**
  * Whether the named paint is a variant in the catalog. Exact, global, and
  * never narrowed by `searchCatalogSubset`, and run only for a `brand` library hit.
@@ -43,7 +43,7 @@ export type ResolveColorVariant = ({
     status: "not-looked-up";
     reason: OpenEnum<"reference-color" | "descriptive-color" | "no-paint-identity" | "generic-color" | "several-paints">;
 };
-export type ResolveColorResponse = {
+export interface ResolveColorResponse {
     /** Examples within the governed range. They do not replace its representative or bounds. */
     rangeSamples?: string[];
     /** Explicit brand choices for an ambiguous paint name. Never selected automatically. */
@@ -73,4 +73,4 @@ export type ResolveColorResponse = {
         /** The catalog lookup for the name. Absent from servers that predate it. */
         variant?: ResolveColorVariant;
     } | null;
-};
+}