@instruments/materialgraph 0.25.0 → 0.26.0

package/catalog-discovery-types.d.ts

@@ -7,15 +7,15 @@
  */
 import type { OpenEnum } from "./types.js";
 /** Options for resolving a free-text value against one attribute's dictionary. */
-export interface ResolveAttributeValueOptions {
+export type ResolveAttributeValueOptions = {
     limit?: number;
-}
+};
 /**
  * One ranked canonical value candidate. `tier` says HOW it matched, strongest
  * first: `exact_id` > `exact_alias` > `lexical` > `semantic`. A `semantic` hit
  * is a guess worth confirming, not an equivalence.
  */
-export interface ResolveValueCandidate {
+export type ResolveValueCandidate = {
     id: string;
     label: string;
     dictionaryId?: string;
@@ -23,7 +23,7 @@ export interface ResolveValueCandidate {
     tier: OpenEnum<"exact_id" | "exact_alias" | "lexical" | "semantic">;
     /** Present only for a colour_family candidate resolved via the colorscope fallback. */
     via?: OpenEnum<"colorscope">;
-}
+};
 /**
  * The resolver's verdict on ONE free-text token — the single shape every
  * resolving surface speaks, so a caller learns to read it once. Returned whole
@@ -45,15 +45,15 @@ export interface ResolveValueCandidate {
  * `query` is the trimmed token that was actually resolved, which is how you tell
  * WHICH half of a failed `attribute:value` pair was the problem.
  */
-export interface ValueResolution {
+export type ValueResolution = {
     status: OpenEnum<"resolved" | "ambiguous" | "unresolved">;
     query: string;
     best: ResolveValueCandidate | null;
     candidates: ResolveValueCandidate[];
     recommendedAction: OpenEnum<"use_best" | "choose_from_candidates" | "ask_user" | "none_found">;
-}
+};
 /** Response from resolving a free-text value against one attribute's dictionary. */
-export interface ResolveAttributeValueResponse {
+export type ResolveAttributeValueResponse = {
     attribute: {
         id: string;
         name: string;
@@ -61,20 +61,20 @@ export interface ResolveAttributeValueResponse {
     };
     /** The verdict on `q`. Read `recommendedAction` — see {@link ValueResolution}. */
     resolution: ValueResolution;
-}
+};
 /** Options for searching registry attributes and value-dictionary terms together. */
-export interface VocabularySearchOptions {
+export type VocabularySearchOptions = {
     limit?: number;
     kind?: "attribute" | "term";
-}
+};
 /** One ranked cross-vocabulary candidate. */
-export interface VocabularySearchCandidate extends ResolveValueCandidate {
+export type VocabularySearchCandidate = {
     kind: OpenEnum<"attribute" | "term">;
     /** Present for terms: attributes whose value dictionary owns this term. */
     attributeIds?: string[];
-}
+} & ResolveValueCandidate;
 /** Response from the cross-vocabulary catalog search. */
-export interface VocabularySearchResponse {
+export type VocabularySearchResponse = {
     query: string;
     results: VocabularySearchCandidate[];
-}
+};

package/catalogue-client.d.ts

@@ -44,10 +44,10 @@ export declare class CatalogueClient {
     samplizeColorVecCache(sourceVersion: string, signal?: AbortSignal): Promise<SamplizeColorVecCache>;
     /** MG-owned full-catalogue facets and directional colour refinement before page limiting. */
     samplizeCatalogueSearch(input: {
-        palette?: Array<{
+        palette?: {
             hex: string;
             proportion: number;
-        }>;
+        }[];
         query?: string;
         reference?: string;
         direction?: "similar" | "lighter" | "darker" | "muted";
@@ -73,13 +73,13 @@ export declare class CatalogueClient {
         rankingVersion?: string;
         dictionaryVersion?: string;
         eligibleCount?: number;
-        groups?: Array<{
+        groups?: {
             hex: string;
             proportion: number;
             quota: number;
             ids: string[];
             shortfall: number;
-        }>;
+        }[];
         ids: string[];
         limited: boolean;
         sourceVersion: string;

package/catalogue-client.js

@@ -6,33 +6,34 @@ export class CatalogueClient {
         this.#transport = transport;
     }
     /** Brand products ranked by observed Material Bank sample-order lines, with window provenance. */
-    brandMostSampled(brandId, options = {}, signal) {
-        return this.#transport.requestJson(resolveOperation("brands.most_sampled"), { query: { brandId, ...options }, signal });
+    async brandMostSampled(brandId, options = {}, signal) {
+        return await this.#transport.requestJson(resolveOperation("brands.most_sampled"), { query: { brandId, ...options }, signal });
     }
     /** Compare canonical Variants without searching or ranking them. */
-    compare(input, signal) {
-        return this.#transport.requestJson(resolveOperation("retrieval.compare"), {
+    async compare(input, signal) {
+        return await this.#transport.requestJson(resolveOperation("retrieval.compare"), {
             body: input,
             signal,
         });
     }
     /** Submit confirmed caller-authored review work; never changes accepted truth. */
-    createCorrection(input, options) {
-        if (!/^[\x21-\x7e]{1,200}$/.test(options.idempotencyKey))
+    async createCorrection(input, options) {
+        if (!/^[\u0021-\u007E]{1,200}$/u.test(options.idempotencyKey)) {
             throw new Error("A valid Idempotency-Key is required for Correction submission.");
-        return this.#transport.requestJson(resolveOperation("corrections.create"), {
+        }
+        return await this.#transport.requestJson(resolveOperation("corrections.create"), {
             body: input,
             ...options,
         });
     }
-    getCorrection(correctionId, signal) {
-        return this.#transport.requestJson(resolveOperation("corrections.get"), {
+    async getCorrection(correctionId, signal) {
+        return await this.#transport.requestJson(resolveOperation("corrections.get"), {
             pathParams: { correctionId },
             signal,
         });
     }
-    listCorrections(input = {}, signal) {
-        return this.#transport.requestJson(resolveOperation("corrections.list"), {
+    async listCorrections(input = {}, signal) {
+        return await this.#transport.requestJson(resolveOperation("corrections.list"), {
             query: input,
             signal,
         });
@@ -44,40 +45,40 @@ export class CatalogueClient {
      * returns the original receipt. This judges the match ranking and is never a
      * catalogue correction - wrong product facts go through `createCorrection`.
      */
-    rejectMatchResult(responseId, input, signal) {
-        return this.#transport.requestJson(resolveOperation("reject_match_result"), { pathParams: { responseId }, body: input, signal });
+    async rejectMatchResult(responseId, input, signal) {
+        return await this.#transport.requestJson(resolveOperation("reject_match_result"), { body: input, pathParams: { responseId }, signal });
     }
     /** Read one match response back with every rejection recorded against it. */
-    matchRejections(responseId, signal) {
-        return this.#transport.requestJson(resolveOperation("list_match_rejections"), { pathParams: { responseId }, signal });
+    async matchRejections(responseId, signal) {
+        return await this.#transport.requestJson(resolveOperation("list_match_rejections"), { pathParams: { responseId }, signal });
     }
     /** Identify the canonical graph subject for one explicitly selected page. */
-    identify(input, signal) {
-        return this.#transport.requestJson(resolveOperation("retrieval.identify"), { body: input, signal });
+    async identify(input, signal) {
+        return await this.#transport.requestJson(resolveOperation("retrieval.identify"), { body: input, signal });
     }
     /** Complete producer-owned vectors and classifications for portable colour matching. */
-    samplizeColorVecCache(sourceVersion, signal) {
-        return this.#transport.requestJson(resolveOperation("samplize_colorvec_cache"), { query: { sourceVersion }, signal });
+    async samplizeColorVecCache(sourceVersion, signal) {
+        return await this.#transport.requestJson(resolveOperation("samplize_colorvec_cache"), { query: { sourceVersion }, signal });
     }
     /** MG-owned full-catalogue facets and directional colour refinement before page limiting. */
-    samplizeCatalogueSearch(input, signal) {
-        return this.#transport.requestJson(resolveOperation("samplize_catalogue_search"), { body: input, signal });
+    async samplizeCatalogueSearch(input, signal) {
+        return await this.#transport.requestJson(resolveOperation("samplize_catalogue_search"), { body: input, signal });
     }
     /** Complete version-pinned Samplize paint corpus; stock never limits eligibility. */
-    samplizeCatalogue(options = {}, signal) {
-        return this.#transport.requestJson(resolveOperation("samplize_catalogue_products"), { query: { ...options }, signal });
+    async samplizeCatalogue(options = {}, signal) {
+        return await this.#transport.requestJson(resolveOperation("samplize_catalogue_products"), { query: { ...options }, signal });
     }
     /**
      * Read exact, verified brand-publication page relationships for variants.
      * Missing evidence stays explicit; this operation never guesses a page from
      * a generic PDF.
      */
-    catalogueReferences(input, signal) {
-        return this.#transport.requestJson(resolveOperation("get_catalogue_references_batch"), { body: input, signal });
+    async catalogueReferences(input, signal) {
+        return await this.#transport.requestJson(resolveOperation("get_catalogue_references_batch"), { body: input, signal });
     }
     /** List product collections with governed catalogue-channel membership. */
-    catalogueCollections(options = {}, signal) {
-        return this.#transport.requestJson(resolveOperation("list_catalogue_channel_collections"), {
+    async catalogueCollections(options = {}, signal) {
+        return await this.#transport.requestJson(resolveOperation("list_catalogue_channel_collections"), {
             query: {
                 limit: options.limit,
                 offset: options.offset,
@@ -87,23 +88,23 @@ export class CatalogueClient {
         });
     }
     /** List immutable catalog documents retained from verified source material. */
-    catalogs(signal) {
-        return this.#transport.requestJson(resolveOperation("list_catalog_documents"), { signal });
+    async catalogs(signal) {
+        return await this.#transport.requestJson(resolveOperation("list_catalog_documents"), { signal });
     }
     /** List stable one-based page identities and their representation status. */
-    catalogPages(catalogId, options = {}, signal) {
-        return this.#transport.requestJson(resolveOperation("list_catalog_pages"), { pathParams: { catalogId }, query: options, signal });
+    async catalogPages(catalogId, options = {}, signal) {
+        return await this.#transport.requestJson(resolveOperation("list_catalog_pages"), { pathParams: { catalogId }, query: options, signal });
     }
     /** Read a retained page representation or its exact missing-artifact receipt. */
-    catalogPageRepresentation(pageId, signal) {
-        return this.#transport.requestJson(resolveOperation("get_catalog_page_representation"), { pathParams: { pageId }, signal });
+    async catalogPageRepresentation(pageId, signal) {
+        return await this.#transport.requestJson(resolveOperation("get_catalog_page_representation"), { pathParams: { pageId }, signal });
     }
     /** Read every verified product/page reference for one retained catalog. */
-    catalogReferences(catalogId, signal) {
-        return this.#transport.requestJson(resolveOperation("list_catalog_product_references"), { pathParams: { catalogId }, signal });
+    async catalogReferences(catalogId, signal) {
+        return await this.#transport.requestJson(resolveOperation("list_catalog_product_references"), { pathParams: { catalogId }, signal });
     }
     /** Resolve browser-safe access to one immutable catalogue document. */
-    catalogueDocumentAccess(documentId, signal) {
-        return this.#transport.requestJson(resolveOperation("get_catalogue_document_access"), { pathParams: { documentId }, signal });
+    async catalogueDocumentAccess(documentId, signal) {
+        return await this.#transport.requestJson(resolveOperation("get_catalogue_document_access"), { pathParams: { documentId }, signal });
     }
 }

package/catalogue-types.d.ts

@@ -188,10 +188,10 @@ export interface CatalogAvailableReceipt {
         pageCount: number;
     };
     render: {
-        failedPages: Array<{
+        failedPages: {
             documentPage: number;
             reason: string;
-        }>;
+        }[];
         renderedPages: number;
         status: "complete" | "partial" | "not_recorded";
     };
@@ -347,10 +347,10 @@ export type CatalogPageListResult = {
     };
     representationCoverage: {
         available: number;
-        failuresByReason: Array<{
+        failuresByReason: {
             count: number;
             reason: "retained_representation_not_found";
-        }>;
+        }[];
         total: number;
         unavailable: number;
     };

package/citation-types.d.ts

@@ -1,10 +1,10 @@
 /** Small handle carried by a verdict cell. Resolve it only when evidence is opened. */
-export interface VerdictCitation {
+export type VerdictCitation = {
     citationId: string;
     sourceType: string;
     count: number;
-}
-export interface ResolvedVerdictCitation {
+};
+export type ResolvedVerdictCitation = {
     citationId: string;
     sourceType: string;
     source: {
@@ -31,4 +31,4 @@ export interface ResolvedVerdictCitation {
             };
         };
     };
-}
+};

package/client-browse.d.ts

@@ -17,10 +17,10 @@ import type { BrowseParams, BrowseResponse } from "./browse-types.js";
  * states no total, so a corpus claim can only come from `.pages()`. Never report
  * one page's length as "how many materials there are".
  */
-export interface BrowseNamespace {
+export type BrowseNamespace = {
     (params: BrowseParams, signal?: AbortSignal): Promise<BrowseResponse>;
     pages(params: BrowseParams, signal?: AbortSignal): AsyncGenerator<BrowseResponse, void, unknown>;
-}
+};
 /** Fetch one page. The client supplies this, so the transport stays private. */
 export type BrowsePageFetcher = (params: BrowseParams, signal?: AbortSignal) => Promise<BrowseResponse>;
 /**
@@ -45,7 +45,7 @@ export type BrowsePageFetcher = (params: BrowseParams, signal?: AbortSignal) =>
  * the array shape and the comma-joined string are each doing exactly what the
  * server expects rather than being two spellings of one idea.
  */
-export declare function browseQuery(params: BrowseParams): {
+export declare const browseQuery: (params: BrowseParams) => {
     sort: BrowseParams["sort"];
     cursor: BrowseParams["cursor"];
     limit: BrowseParams["limit"];
@@ -75,4 +75,4 @@ export declare function browsePages(fetchPage: BrowsePageFetcher, params: Browse
  * const page = await client.browse({ sort: "lightest" });
  * for await (const page of client.browse.pages({ sort: "lightest" })) { … }
  */
-export declare function createBrowseNamespace(fetchPage: BrowsePageFetcher): BrowseNamespace;
+export declare const createBrowseNamespace: (fetchPage: BrowsePageFetcher) => BrowseNamespace;

package/client-browse.js

@@ -20,26 +20,24 @@
  * the array shape and the comma-joined string are each doing exactly what the
  * server expects rather than being two spellings of one idea.
  */
-export function browseQuery(params) {
-    return {
-        sort: params.sort,
-        cursor: params.cursor,
-        limit: params.limit,
-        count: params.count,
-        types: params.types,
-        brands: params.brands,
-        role: params.role,
-        filters: params.filters?.map((entry) => JSON.stringify(entry)),
-        facetCounts: params.facetCounts?.join(","),
-        corpusScope: params.corpusScope,
-        // `orderBy` is JSON-encoded and `returnAttributes` comma-joined because that
-        // is what the route reads — the same two transports `filters` and
-        // `facetCounts` already use. Enrolled HERE at the same time they shipped on
-        // the route, which is the thing the three misses above did not do.
-        orderBy: params.orderBy ? JSON.stringify(params.orderBy) : undefined,
-        returnAttributes: params.returnAttributes?.join(","),
-    };
-}
+export const browseQuery = (params) => ({
+    brands: params.brands,
+    corpusScope: params.corpusScope,
+    count: params.count,
+    cursor: params.cursor,
+    facetCounts: params.facetCounts?.join(","),
+    filters: params.filters?.map((entry) => JSON.stringify(entry)),
+    limit: params.limit,
+    // `orderBy` is JSON-encoded and `returnAttributes` comma-joined because that
+    // is what the route reads — the same two transports `filters` and
+    // `facetCounts` already use. Enrolled HERE at the same time they shipped on
+    // the route, which is the thing the three misses above did not do.
+    orderBy: params.orderBy ? JSON.stringify(params.orderBy) : undefined,
+    returnAttributes: params.returnAttributes?.join(","),
+    role: params.role,
+    sort: params.sort,
+    types: params.types,
+});
 /**
  * Walk every page from `params.cursor` onward.
  *
@@ -49,12 +47,13 @@ export function browseQuery(params) {
  * not an error anyone can see.
  */
 export async function* browsePages(fetchPage, params, signal) {
-    let cursor = params.cursor;
+    let { cursor } = params;
     for (;;) {
         const page = await fetchPage({ ...params, cursor }, signal);
         yield page;
-        if (page.cursor === undefined || page.results.length === 0)
+        if (page.cursor === undefined || page.results.length === 0) {
             return;
+        }
         cursor = page.cursor;
     }
 }
@@ -65,8 +64,8 @@ export async function* browsePages(fetchPage, params, signal) {
  * const page = await client.browse({ sort: "lightest" });
  * for await (const page of client.browse.pages({ sort: "lightest" })) { … }
  */
-export function createBrowseNamespace(fetchPage) {
-    const browse = (params, signal) => fetchPage(params, signal);
+export const createBrowseNamespace = (fetchPage) => {
+    const browse = async (params, signal) => await fetchPage(params, signal);
     browse.pages = (params, signal) => browsePages(fetchPage, params, signal);
     return browse;
-}
+};

package/client-config.d.ts

@@ -7,11 +7,11 @@
 export declare const DEFAULT_BASE_URL = "https://beta.materialgraph.com";
 /** The server's per-call ceiling on batch material lookups, enforced client-side. */
 export declare const MAX_BATCH_IDS = 100;
-export interface MaterialGraphClientOptions {
+export type MaterialGraphClientOptions = {
     /** A `mg_read_*` API key, presented as `Authorization: Bearer <key>`. */
     apiKey: string;
     /** Override the API origin. Defaults to {@link DEFAULT_BASE_URL}. */
     baseUrl?: string;
     /** Inject a custom `fetch` (tests, proxies). Defaults to the global `fetch`. */
     fetch?: typeof fetch;
-}
+};

package/client-exploration.d.ts

@@ -2,8 +2,8 @@ import type { CandidateReadInput, CandidateReadResponse, GraphOperatorEvidence }
 import type { HttpTransport } from "./http-transport.js";
 import type { VariantId } from "./identifiers.js";
 /** Discovery and traversal share one namespace so availability precedes use. */
-export interface ExplorationNamespace {
+export type ExplorationNamespace = {
     operators(variantId: VariantId, signal?: AbortSignal): Promise<GraphOperatorEvidence>;
     candidates(variantId: VariantId, input: CandidateReadInput, signal?: AbortSignal): Promise<CandidateReadResponse>;
-}
-export declare function createExplorationNamespace(transport: HttpTransport): ExplorationNamespace;
+};
+export declare const createExplorationNamespace: (transport: HttpTransport) => ExplorationNamespace;

package/client-exploration.js

@@ -1,7 +1,5 @@
 import { resolveOperation } from "./operations.js";
-export function createExplorationNamespace(transport) {
-    return {
-        operators: (variantId, signal) => transport.requestJson(resolveOperation("list_material_operators"), { pathParams: { variantId }, signal }),
-        candidates: (variantId, input, signal) => transport.requestJson(resolveOperation("read_material_candidates"), { body: input, pathParams: { variantId }, signal }),
-    };
-}
+export const createExplorationNamespace = (transport) => ({
+    candidates: async (variantId, input, signal) => await transport.requestJson(resolveOperation("read_material_candidates"), { body: input, pathParams: { variantId }, signal }),
+    operators: async (variantId, signal) => await transport.requestJson(resolveOperation("list_material_operators"), { pathParams: { variantId }, signal }),
+});

package/client-source-material-comments.d.ts

@@ -29,9 +29,9 @@
  * namespace over a batch's files to rebuild what that read returns. Reach for
  * `list` when you are watching a single file.
  */
-import { HttpTransport } from "./http-transport.js";
+import type { HttpTransport } from "./http-transport.js";
 import type { PostSourceMaterialCommentInput, PostSourceMaterialCommentResult, SourceMaterialCommentThread } from "./run-types.js";
-export interface SourceMaterialCommentsNamespace {
+export type SourceMaterialCommentsNamespace = {
     /**
      * One file's thread, oldest root first, each root carrying its replies.
      * `comments` is always an array; `truncated` says whether you are holding the
@@ -46,6 +46,6 @@ export interface SourceMaterialCommentsNamespace {
      * permanent duplicate.
      */
     post(batchId: string, sourceId: string, input: PostSourceMaterialCommentInput, signal?: AbortSignal): Promise<PostSourceMaterialCommentResult>;
-}
+};
 /** Bind the comment operations to the client's shared transport. */
-export declare function createSourceMaterialCommentsNamespace(transport: HttpTransport): SourceMaterialCommentsNamespace;
+export declare const createSourceMaterialCommentsNamespace: (transport: HttpTransport) => SourceMaterialCommentsNamespace;

package/client-source-material-comments.js

@@ -1,40 +1,6 @@
-/**
- * The per-file comment surface, namespaced as `mg.sourceMaterialComments` — the
- * argument people leave on one uploaded file (MG-1345).
- *
- * A namespace rather than two more flat methods on an already-large facade,
- * following `mg.codes` and `mg.colours`: reading a thread and adding to it are
- * one family, they share a `(batchId, sourceId)` referent, and neither makes
- * sense without the other. The namespace holds no transport of its own — the
- * client hands it the shared one, so auth, rate-limit accounting and error
- * shaping stay in one place.
- *
- * TWO RULES A CONSUMER MUST NOT GET WRONG.
- *
- * **The author name is REPORTED, never verified.** Every comment carries
- * `author.attribution: "reported"` — a name somebody typed — plus `recordedBy`,
- * the authenticated principal that actually wrote the row. Render "recorded as
- * from Ruth Fielding", never "Ruth Fielding said". The API takes a machine key,
- * and the person whose argument a remark carries is usually not the person at
- * the keyboard; presenting the one as the other is the failure this field
- * exists to prevent.
- *
- * **A reply is not a root.** {@link SourceMaterialCommentsNamespace.post}
- * returns a result discriminated on `kind`: switch on it rather than reaching
- * for `replies`, which a `reply` does not have. Threads are one level deep and
- * the database enforces it, so a reply can never grow replies of its own.
- *
- * ROUTING OUT OF THIS NAMESPACE. `mg.sourceMaterialBatch(batchId)` already
- * inlines every file's thread, so opening a batch is ONE call — do not loop this
- * namespace over a batch's files to rebuild what that read returns. Reach for
- * `list` when you are watching a single file.
- */
-import { HttpTransport } from "./http-transport.js";
 import { listSourceMaterialComments, postSourceMaterialComment, } from "./runs.js";
 /** Bind the comment operations to the client's shared transport. */
-export function createSourceMaterialCommentsNamespace(transport) {
-    return {
-        list: (batchId, sourceId, signal) => listSourceMaterialComments(transport, batchId, sourceId, signal),
-        post: (batchId, sourceId, input, signal) => postSourceMaterialComment(transport, batchId, sourceId, input, signal),
-    };
-}
+export const createSourceMaterialCommentsNamespace = (transport) => ({
+    list: async (batchId, sourceId, signal) => await listSourceMaterialComments(transport, batchId, sourceId, signal),
+    post: async (batchId, sourceId, input, signal) => await postSourceMaterialComment(transport, batchId, sourceId, input, signal),
+});

package/client-vocabulary.d.ts

@@ -1,10 +1,10 @@
-import { HttpTransport } from "./http-transport.js";
+import type { HttpTransport } from "./http-transport.js";
 import type { ColourFacetsResponse, ResolveAttributeOptions, ResolveAttributeResponse, ResolveAttributeValueOptions, ResolveAttributeValueResponse, ResolveColourOptions, ResolveColourResponse, SuggestColourResponse, SuggestOptions, SuggestResponse } from "./types.js";
-export declare function colourFacets(transport: HttpTransport, signal?: AbortSignal): Promise<ColourFacetsResponse>;
-export declare function resolveColour(transport: HttpTransport, name: string, signal?: AbortSignal, options?: ResolveColourOptions): Promise<ResolveColourResponse>;
-export declare function suggestColour(transport: HttpTransport, q: string, options?: {
+export declare const colourFacets: (transport: HttpTransport, signal?: AbortSignal) => Promise<ColourFacetsResponse>;
+export declare const resolveColour: (transport: HttpTransport, name: string, signal?: AbortSignal, options?: ResolveColourOptions) => Promise<ResolveColourResponse>;
+export declare const suggestColour: (transport: HttpTransport, q: string, options?: {
     limit?: number;
-}, signal?: AbortSignal): Promise<SuggestColourResponse>;
-export declare function suggest(transport: HttpTransport, q: string, options?: SuggestOptions, signal?: AbortSignal): Promise<SuggestResponse>;
-export declare function resolveAttribute(transport: HttpTransport, q: string, options?: ResolveAttributeOptions, signal?: AbortSignal): Promise<ResolveAttributeResponse>;
-export declare function resolveAttributeValue(transport: HttpTransport, attributeId: string, query: string, options?: ResolveAttributeValueOptions, signal?: AbortSignal): Promise<ResolveAttributeValueResponse>;
+}, signal?: AbortSignal) => Promise<SuggestColourResponse>;
+export declare const suggest: (transport: HttpTransport, q: string, options?: SuggestOptions, signal?: AbortSignal) => Promise<SuggestResponse>;
+export declare const resolveAttribute: (transport: HttpTransport, q: string, options?: ResolveAttributeOptions, signal?: AbortSignal) => Promise<ResolveAttributeResponse>;
+export declare const resolveAttributeValue: (transport: HttpTransport, attributeId: string, query: string, options?: ResolveAttributeValueOptions, signal?: AbortSignal) => Promise<ResolveAttributeValueResponse>;

package/client-vocabulary.js

@@ -1,32 +1,22 @@
-import { HttpTransport } from "./http-transport.js";
 import { resolveOperation } from "./operations.js";
 import { suggestQuery } from "./suggest-types.js";
-export function colourFacets(transport, signal) {
-    return transport.requestJson(resolveOperation("get_colour_facets"), { signal });
-}
-export function resolveColour(transport, name, signal, options) {
-    return transport.requestJson(resolveOperation("resolve_colour_name"), { query: { name, corpusScope: options?.corpusScope }, signal });
-}
-export function suggestColour(transport, q, options, signal) {
-    return transport.requestJson(resolveOperation("suggest_colour_names"), { query: { q, limit: options?.limit }, signal });
-}
-export function suggest(transport, q, options, signal) {
-    return transport.requestJson(resolveOperation("search_suggest"), { query: suggestQuery(q, options), signal });
-}
-export function resolveAttribute(transport, q, options, signal) {
-    return transport.requestJson(resolveOperation("catalog_resolve_attribute"), {
-        query: {
-            q,
-            limit: options?.limit,
-            facetableOnly: options?.facetableOnly,
-        },
-        signal,
-    });
-}
-export function resolveAttributeValue(transport, attributeId, query, options, signal) {
-    return transport.requestJson(resolveOperation("catalog_resolve_value"), {
-        query: { q: query, limit: options?.limit },
-        pathParams: { attributeId },
-        signal,
-    });
-}
+export const colourFacets = async (transport, signal) => await transport.requestJson(resolveOperation("get_colour_facets"), { signal });
+export const resolveColour = async (transport, name, signal, options) => await transport.requestJson(resolveOperation("resolve_colour_name"), { query: { corpusScope: options?.corpusScope, name }, signal });
+export const suggestColour = async (transport, q, options, signal) => await transport.requestJson(resolveOperation("suggest_colour_names"), { query: { limit: options?.limit, q }, signal });
+export const suggest = async (transport, q, options, signal) => await transport.requestJson(resolveOperation("search_suggest"), {
+    query: suggestQuery(q, options),
+    signal,
+});
+export const resolveAttribute = async (transport, q, options, signal) => await transport.requestJson(resolveOperation("catalog_resolve_attribute"), {
+    query: {
+        facetableOnly: options?.facetableOnly,
+        limit: options?.limit,
+        q,
+    },
+    signal,
+});
+export const resolveAttributeValue = async (transport, attributeId, query, options, signal) => await transport.requestJson(resolveOperation("catalog_resolve_value"), {
+    pathParams: { attributeId },
+    query: { limit: options?.limit, q: query },
+    signal,
+});