@instruments/materialgraph 0.1.0 → 0.3.0

package/composition-types.d.ts

@@ -0,0 +1,343 @@
+/**
+ * Hand-mirrored wire types for the synchronous composition-variation surface
+ * (`POST /api/v1/schemes/vary`, operation `vary_schemes`, MG-438). Like the rest
+ * of the SDK these interfaces carry NO runtime dependency on any
+ * `@materialgraph/*` package — they mirror the `VarySchemesRequest` /
+ * `VarySchemesResponse` shapes in `apps/web/public/openapi.yaml`.
+ *
+ * Vary is deterministic and synchronous: it re-derives an "option B" from a
+ * succeeded `compose-material-schemes` Run along one constraint axis, so unlike
+ * the async Run surface the response IS the scheme — no run envelope, no events.
+ *
+ * TOLERANT-PARSING CONTRACT: response enums are widened with {@link OpenEnum}
+ * so a new server value still type-checks; objects are read structurally.
+ */
+import type { OpenEnum } from "./types.js";
+/**
+ * The four v1 variation axes. Request-side, so this is a STRICT union (the
+ * caller picks exactly one). `uniqueness` is deferred server-side (MG-445).
+ */
+export type VaryAxis = "palette" | "sustainability" | "brandDiversity" | "priceTier";
+/**
+ * The variation axes as a runtime array, for consumers that render an axis
+ * picker. Order is the canonical presentation order.
+ */
+export declare const VARY_AXES: readonly VaryAxis[];
+/** Pin one slot to a specific variant so vary re-derives only the rest. */
+export interface SchemeLock {
+    slotId: string;
+    /** Must equal that slot's CURRENT pick in the source scheme. */
+    variantId: string;
+}
+/** Candidate exclusions applied on top of the automatic source-pick exclusion. */
+export interface SchemeExclusions {
+    variantIds?: string[];
+    brandSlugs?: string[];
+}
+/** Body for `POST /api/v1/schemes/vary` ({@link MaterialGraphClient.varyScheme}). */
+export interface VarySchemesRequest {
+    /** The succeeded `compose-material-schemes` Run to vary from. */
+    runId: string;
+    /** Which scheme in the Run is option A. Defaults to the Run's FIRST scheme. */
+    schemeId?: string;
+    axis: VaryAxis;
+    /** Slots kept pinned to their source pick; only unlocked slots re-derive. */
+    locks?: SchemeLock[];
+    exclusions?: SchemeExclusions;
+}
+/**
+ * One anchor (MG-613): a variant the designer has already pinned to a place in
+ * the programme, supplied on the `compose-material-schemes` run input's
+ * `anchors[]`. Exactly ONE of `variantId` (an exact catalog variant) or `query`
+ * (free-text "Brand Product Colour", resolved server-side) is required. An
+ * anchored slot is LOCKED — composition completes the OPEN slots in relation to
+ * it. Anchors that cannot be resolved leave the slot open and surface a run
+ * warning (never a failure).
+ */
+export interface ComposeAnchorInput {
+    /** The building element the anchor fills (flooring, wall, textile, …). */
+    element: SlotElement;
+    /** Optional named space to scope the anchor to (matched by name/slug). */
+    spaceName?: string;
+    /** An exact catalog variant id. Mutually exclusive with `query`. */
+    variantId?: string;
+    /** Free-text "Brand Product Colour". Mutually exclusive with `variantId`. */
+    query?: string;
+    /** Display name for slot naming and warnings. */
+    label?: string;
+}
+/**
+ * One standing rule in a project's compliance preset (MG-615): free-text
+ * `criteria` phrases that apply to a `scope` of slots. `scope: "all"` reaches
+ * every slot (including slots with no element and slots classified `other`); a
+ * named element reaches only slots carrying exactly that element, so an
+ * unclassified slot receives `"all"` rules only. Phrases are resolved
+ * server-side through the same vocabulary as brief criteria — sustainability
+ * wording ("LEED", "GREENGUARD Gold") resolves to a named certification
+ * programme. A phrase that grounds to nothing is dropped with a run warning.
+ */
+export interface CompliancePresetRule {
+    scope: "all" | SlotElement;
+    criteria: string[];
+}
+/** A project's standing rules, declared once on the compose run (max 12 rules). */
+export interface CompliancePreset {
+    rules: CompliancePresetRule[];
+}
+/**
+ * The `inputJson` for a `compose-material-schemes` run. `batchId` is required;
+ * everything else has a server default. `anchors` (max 24) carry externally
+ * decided picks (MG-613); `compliancePreset` carries the project's standing
+ * rules (MG-615), which cascade into slots as PREFERRED criteria — they grade
+ * every candidate but never exclude one.
+ */
+export interface ComposeMaterialSchemesInput {
+    batchId: string;
+    count?: number;
+    seed?: number;
+    exclusions?: SchemeExclusions;
+    anchors?: ComposeAnchorInput[];
+    compliancePreset?: CompliancePreset;
+}
+/**
+ * The state of one criterion verdict cell (MG-627: the shared MaterialGraph
+ * verdict states). The six LIVE states are `matched` (accepted value satisfies
+ * the criterion), `deviated` (directionally off but named), `failed` (an
+ * accepted value exists and does not satisfy it), `unverified` (a real value
+ * that did not clear the trust bar), `missing` (no accepted value to evaluate),
+ * and `not_evaluated` (the engine did not check it). `mismatched`/`unknown` are
+ * the two LEGACY tokens old persisted runs still carry (never emitted again).
+ * Open per the response-enum policy: treat unknown states forward-compatibly.
+ */
+export type CompositionMatchState = OpenEnum<"matched" | "deviated" | "failed" | "unverified" | "missing" | "not_evaluated" | "mismatched" | "unknown">;
+/** How a criterion cell was baselined — what the candidate was compared against. */
+export type CompositionMatchBaseline = {
+    kind: "term";
+    term: string;
+} | {
+    kind: "presence";
+} | {
+    kind: "seed";
+    variantId: string;
+};
+/** One resolved criterion → material verdict cell, as graded during composition. */
+export interface CompositionMatch {
+    attributeId: string;
+    state: CompositionMatchState;
+    confidence: number | null;
+    sourceBasis: string | null;
+    /** Required vs preferred criterion (MG-627). Absent on legacy persisted runs. */
+    strength?: "required" | "preferred";
+    /** What the cell was evaluated against (MG-627). Absent on legacy persisted runs. */
+    baseline?: CompositionMatchBaseline;
+    /** The candidate's own accepted value label, when the cell carries one (MG-627). */
+    value?: string | null;
+    /** Why an `unverified` cell missed the trust bar (MG-627), else null. */
+    trustGap?: "below_confidence" | "basis_unmet" | "proposed" | null;
+}
+/** One slot's chosen material plus the reason it was picked. */
+export interface CompositionPick {
+    slotId: string;
+    slotName: string;
+    spaceId?: string | null;
+    element?: string | null;
+    material: {
+        variantId: string;
+        brand: string;
+        product: string;
+        variant: string;
+        imageUrl: string | null;
+        hex: string | null;
+    };
+    reason: {
+        score: number;
+        matched: CompositionMatch[];
+        notes: string[];
+    };
+    /**
+     * True when this pick is an ANCHOR the designer pinned to the slot (MG-613):
+     * composition never replaced it and vary keeps it fixed. Absent for ordinary
+     * composed picks.
+     */
+    locked?: boolean;
+}
+/** The multi-objective score for one scheme (each component in [0, 1]). */
+export interface CompositionObjective {
+    total: number;
+    briefFit: number;
+    coverage: number;
+    coherence: number;
+    novelty: number;
+}
+/** A hydrated scheme: one pick per slot, plus its objective breakdown. */
+export interface CompositionScheme {
+    schemeId: string;
+    title: string;
+    picks: CompositionPick[];
+    objective: CompositionObjective;
+}
+/** How far short of the request the derivation fell, with honest reasons. */
+export interface CompositionShortfall {
+    requested: number;
+    produced: number;
+    reasons: string[];
+}
+/** The axis + source provenance stamped onto every varied scheme. */
+export interface VaryProvenance {
+    axis: VaryAxis;
+    sourceRunId: string;
+    sourceSchemeId: string;
+    lockedSlotIds: string[];
+    /**
+     * Human-readable notes recording exactly what the axis did — counts, not
+     * adjectives (e.g. "brandDiversity: hard-excluded 2 brand(s) appearing ≥2×").
+     * These are the variation's receipts.
+     */
+    notes: string[];
+}
+/** The `200` body from `POST /api/v1/schemes/vary`. */
+export interface VarySchemesResponse {
+    /** The composition version the scheme was stamped with. */
+    version: string;
+    scheme: CompositionScheme;
+    provenance: VaryProvenance;
+    shortfall: CompositionShortfall | null;
+}
+/**
+ * Whether a programme element (space, slot, or palette) was `stated` in a text
+ * source or `inferred` from imagery/mood. Only inferred elements raise a review
+ * question. Absent → treated as `stated`.
+ */
+export type ProgrammeProvenance = "stated" | "inferred";
+/**
+ * The broad building element a slot fills — a pragmatically-extended Uniclass EF
+ * vocabulary. Widened with {@link OpenEnum} so a newer server term still
+ * type-checks.
+ */
+export type SlotElement = OpenEnum<"flooring" | "wall" | "ceiling" | "textile" | "surface" | "furniture" | "lighting" | "other">;
+/** One colour cue: a hex swatch with an optional human name. */
+export interface BriefColourCue {
+    hex: string;
+    name?: string;
+}
+/** A source anchor (document id + optional page) attributing derived content. */
+export interface CompositionSourceRef {
+    sourceId: string;
+    page: number | null;
+}
+/**
+ * One candidate colour direction the pile's colour evidence implies when no
+ * palette was explicitly committed. `directionId` is a stable kebab-case handle;
+ * `sourceRefs` attribute the direction to the palette source(s) it was drawn
+ * from (empty when unattributable).
+ */
+export interface PaletteDirection {
+    directionId: string;
+    name: string;
+    colours: BriefColourCue[];
+    sourceRefs: CompositionSourceRef[];
+}
+/**
+ * Suspend payload for the compose `review-programme` step: the FULL programme
+ * picture — every space and slot tagged with its provenance — so the card can
+ * show the whole thing and highlight what was inferred.
+ */
+export interface ReviewProgrammeSuspendPayload {
+    spaces: Array<{
+        spaceId: string;
+        name: string;
+        spaceType?: string;
+        provenance: ProgrammeProvenance;
+    }>;
+    slots: Array<{
+        slotId: string;
+        name: string;
+        spaceId?: string;
+        element?: SlotElement;
+        provenance: ProgrammeProvenance;
+    }>;
+}
+/**
+ * Resume grammar for the `review-programme` step: drop a slot, drop a space
+ * (cascade-dropping its slots), or rename a space.
+ */
+export interface ReviewProgrammeResumeData {
+    corrections: Array<{
+        action: "drop-slot";
+        slotId: string;
+    } | {
+        action: "drop-space";
+        spaceId: string;
+    } | {
+        action: "rename-space";
+        spaceId: string;
+        name: string;
+    }>;
+}
+/**
+ * Suspend payload for the compose `commit-palette` step. Today only the
+ * `directions` mode ships; the shape carries `mode` so a later `ab-images` mode
+ * is an additive member, not a migration.
+ */
+export interface CommitPaletteSuspendPayload {
+    mode: OpenEnum<"directions">;
+    directions: PaletteDirection[];
+}
+/**
+ * Resume grammar for the `commit-palette` step: commit to one direction (by id)
+ * or adopt the union of every direction's colours.
+ */
+export type CommitPaletteResumeData = {
+    choice: "direction";
+    directionId: string;
+} | {
+    choice: "all";
+};
+/**
+ * Resume grammar for the `review-material-criteria` step: accept a resolved
+ * attribute/term for an unresolved phrase, or drop it.
+ */
+export interface ReviewCriteriaResumeData {
+    corrections: Array<{
+        action: "accept";
+        slotId: string;
+        raw: string;
+        attributeId: string;
+        term?: string;
+    } | {
+        action: "drop";
+        slotId: string;
+        raw: string;
+    }>;
+}
+/** The union of every socratic-step resume payload, keyed by the suspended step. */
+export type InterviewResumeData = ReviewCriteriaResumeData | ReviewProgrammeResumeData | CommitPaletteResumeData;
+/** The three socratic interview steps, in procedure order. */
+export type InterviewStepId = "review-programme" | "commit-palette" | "review-material-criteria";
+/**
+ * Payload of a `composition.answered` event — the pile answered a question with
+ * no human turn, or a suspension resolved. `answer` is a stable slug; `citation`
+ * attributes an answer to its source when the brief stated it.
+ */
+export interface CompositionAnsweredPayload {
+    step: InterviewStepId;
+    answer: string;
+    citation: CompositionSourceRef | null;
+    counts?: Record<string, number>;
+}
+/**
+ * Payload of a `composition.slot-pool` event — the candidate theater for one
+ * slot: how many were considered and the top picks (≤5) hydrated for identity.
+ */
+export interface SlotPoolEventPayload {
+    slotId: string;
+    slotName: string;
+    considered: number;
+    top: Array<{
+        variantId: string;
+        brand: string;
+        product: string;
+        imageUrl: string | null;
+        score: number;
+    }>;
+}

package/composition-types.js

@@ -0,0 +1,10 @@
+/**
+ * The variation axes as a runtime array, for consumers that render an axis
+ * picker. Order is the canonical presentation order.
+ */
+export const VARY_AXES = Object.freeze([
+    "palette",
+    "sustainability",
+    "brandDiversity",
+    "priceTier",
+]);

package/http-transport.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The shared low-level HTTP transport for {@link MaterialGraphClient}. It owns
+ * URL building, the bearer header, rate-limit capture, response reading, and the
+ * one error-mapping path — so the JSON read surface (`client.ts`), the multipart
+ * upload, the SSE stream (`runs.ts`), and the NDJSON Match stream
+ * (`match-stream.ts`) all fail identically. Retry-free by design; a single
+ * failure surfaces as one {@link MaterialGraphError}.
+ */
+import { type RateLimit } from "./errors.js";
+import { type SdkOperation } from "./operations.js";
+export type QueryValue = string | number | boolean | undefined | null | Array<string | number | boolean>;
+export type QueryParams = Record<string, QueryValue>;
+export interface RequestOptions {
+    query?: QueryParams;
+    body?: unknown;
+    signal?: AbortSignal;
+    pathParams?: Readonly<Record<string, string>>;
+}
+export interface StreamRequestOptions extends RequestOptions {
+    /** The streaming media type to negotiate (`text/event-stream`, `application/x-ndjson`). */
+    accept: string;
+    /** Names this stream in the "returned no body" diagnostic, e.g. `"match stream"`. */
+    subject: string;
+}
+/** A read, status-checked HTTP response with its parsed body. */
+export interface SentResponse {
+    response: Response;
+    text: string;
+    parsed: unknown;
+}
+interface SendInput {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    /** The only bodies the SDK sends: a JSON string or a multipart `FormData`. */
+    body?: string | FormData;
+    signal?: AbortSignal;
+}
+export interface HttpTransportOptions {
+    apiKey: string;
+    baseUrl: string;
+    fetch: typeof fetch;
+}
+export declare class HttpTransport {
+    #private;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly fetch: typeof fetch;
+    constructor(options: HttpTransportOptions);
+    get lastRateLimit(): RateLimit | null;
+    /** The bearer + JSON `Accept` headers, plus any per-request additions. */
+    authHeaders(extra?: Record<string, string>): Record<string, string>;
+    buildUrl(path: string, query?: QueryParams): string;
+    /**
+     * Send one request, capture rate limits, read the body, and map a non-2xx or
+     * transport failure to a {@link MaterialGraphError}. The parsed JSON body (or
+     * raw text when unparseable) is returned on success. Not for streaming reads —
+     * it consumes the whole body via `response.text()`.
+     */
+    send(input: SendInput): Promise<SentResponse>;
+    /**
+     * Open a streaming operation and hand back its UNREAD byte body — the one
+     * entry point for every long-lived read (SSE run events, NDJSON Match
+     * progress). Everything up to the first byte behaves exactly like
+     * {@link send}: same URL building, same bearer header, same rate-limit
+     * capture, same {@link MaterialGraphError} mapping for a transport failure or
+     * a non-2xx (whose short error body IS read, since it is not a stream).
+     * Framing and cancellation belong to the caller.
+     */
+    openStream(sdkOperation: SdkOperation, options: StreamRequestOptions): Promise<ReadableStream<Uint8Array>>;
+    /** Execute a registered JSON operation and return its typed body. */
+    requestJson<T>(sdkOperation: SdkOperation, options?: RequestOptions): Promise<T>;
+}
+export {};

package/http-transport.js

@@ -0,0 +1,201 @@
+/**
+ * The shared low-level HTTP transport for {@link MaterialGraphClient}. It owns
+ * URL building, the bearer header, rate-limit capture, response reading, and the
+ * one error-mapping path — so the JSON read surface (`client.ts`), the multipart
+ * upload, the SSE stream (`runs.ts`), and the NDJSON Match stream
+ * (`match-stream.ts`) all fail identically. Retry-free by design; a single
+ * failure surfaces as one {@link MaterialGraphError}.
+ */
+import { MaterialGraphError } from "./errors.js";
+import { operationPath } from "./operations.js";
+function parseIntOrNull(value) {
+    if (value === null)
+        return null;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+function parseRateLimit(headers) {
+    const limit = parseIntOrNull(headers.get("x-ratelimit-limit"));
+    const remaining = parseIntOrNull(headers.get("x-ratelimit-remaining"));
+    const reset = parseIntOrNull(headers.get("x-ratelimit-reset"));
+    const retryAfter = parseIntOrNull(headers.get("retry-after"));
+    if (limit === null && remaining === null && reset === null && retryAfter === null) {
+        return null;
+    }
+    return { limit, remaining, reset, retryAfter };
+}
+export class HttpTransport {
+    baseUrl;
+    apiKey;
+    fetch;
+    #lastRateLimit = null;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this.fetch = options.fetch;
+    }
+    get lastRateLimit() {
+        return this.#lastRateLimit;
+    }
+    /** The bearer + JSON `Accept` headers, plus any per-request additions. */
+    authHeaders(extra) {
+        return { Authorization: `Bearer ${this.apiKey}`, Accept: "application/json", ...extra };
+    }
+    buildUrl(path, query) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value === undefined || value === null)
+                    continue;
+                if (Array.isArray(value)) {
+                    for (const item of value) {
+                        if (item !== undefined && item !== null)
+                            url.searchParams.append(key, String(item));
+                    }
+                }
+                else {
+                    url.searchParams.append(key, String(value));
+                }
+            }
+        }
+        return url.toString();
+    }
+    /**
+     * Send one request, capture rate limits, read the body, and map a non-2xx or
+     * transport failure to a {@link MaterialGraphError}. The parsed JSON body (or
+     * raw text when unparseable) is returned on success. Not for streaming reads —
+     * it consumes the whole body via `response.text()`.
+     */
+    async send(input) {
+        const requestUrl = new URL(input.url);
+        const metadata = {
+            method: input.method,
+            origin: requestUrl.origin,
+            path: requestUrl.pathname,
+        };
+        let response;
+        try {
+            response = await this.fetch(input.url, {
+                method: input.method,
+                headers: input.headers,
+                body: input.body,
+                signal: input.signal,
+            });
+        }
+        catch (cause) {
+            throw MaterialGraphError.fromTransport({ ...metadata, cause, callerSignal: input.signal });
+        }
+        const rateLimit = parseRateLimit(response.headers);
+        this.#lastRateLimit = rateLimit;
+        let text;
+        try {
+            text = await response.text();
+        }
+        catch (cause) {
+            throw MaterialGraphError.fromTransport({ ...metadata, cause, callerSignal: input.signal });
+        }
+        let parsed;
+        if (text.length > 0) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = text;
+            }
+        }
+        if (!response.ok) {
+            throw MaterialGraphError.fromResponse({
+                ...metadata,
+                status: response.status,
+                body: parsed,
+                responseText: text,
+                rateLimit,
+                apiKey: this.apiKey,
+                queryValues: [...requestUrl.searchParams.values()],
+            });
+        }
+        return { response, text, parsed };
+    }
+    /**
+     * Open a streaming operation and hand back its UNREAD byte body — the one
+     * entry point for every long-lived read (SSE run events, NDJSON Match
+     * progress). Everything up to the first byte behaves exactly like
+     * {@link send}: same URL building, same bearer header, same rate-limit
+     * capture, same {@link MaterialGraphError} mapping for a transport failure or
+     * a non-2xx (whose short error body IS read, since it is not a stream).
+     * Framing and cancellation belong to the caller.
+     */
+    async openStream(sdkOperation, options) {
+        const url = this.buildUrl(operationPath(sdkOperation, options.pathParams), options.query);
+        const requestUrl = new URL(url);
+        const metadata = {
+            method: sdkOperation.method,
+            origin: requestUrl.origin,
+            path: requestUrl.pathname,
+        };
+        const hasBody = options.body !== undefined;
+        let response;
+        try {
+            response = await this.fetch(url, {
+                method: sdkOperation.method,
+                headers: this.authHeaders({
+                    Accept: options.accept,
+                    ...(hasBody ? { "Content-Type": "application/json" } : {}),
+                }),
+                body: hasBody ? JSON.stringify(options.body) : undefined,
+                signal: options.signal,
+            });
+        }
+        catch (cause) {
+            throw MaterialGraphError.fromTransport({ ...metadata, cause, callerSignal: options.signal });
+        }
+        const rateLimit = parseRateLimit(response.headers);
+        this.#lastRateLimit = rateLimit;
+        if (!response.ok) {
+            let text = "";
+            try {
+                text = await response.text();
+            }
+            catch {
+                // The status IS the error; a body that will not read adds nothing and
+                // must not mask it. Report the failure with an empty detail instead.
+                text = "";
+            }
+            let parsed;
+            if (text.length > 0) {
+                try {
+                    parsed = JSON.parse(text);
+                }
+                catch {
+                    parsed = text;
+                }
+            }
+            throw MaterialGraphError.fromResponse({
+                ...metadata,
+                status: response.status,
+                body: parsed,
+                responseText: text,
+                rateLimit,
+                apiKey: this.apiKey,
+                queryValues: [...requestUrl.searchParams.values()],
+            });
+        }
+        if (response.body === null) {
+            throw MaterialGraphError.unexpected(`MaterialGraph ${options.subject} returned no body`);
+        }
+        return response.body;
+    }
+    /** Execute a registered JSON operation and return its typed body. */
+    async requestJson(sdkOperation, options = {}) {
+        const url = this.buildUrl(operationPath(sdkOperation, options.pathParams), options.query);
+        const hasBody = options.body !== undefined;
+        const { parsed } = await this.send({
+            method: sdkOperation.method,
+            url,
+            headers: this.authHeaders(hasBody ? { "Content-Type": "application/json" } : undefined),
+            body: hasBody ? JSON.stringify(options.body) : undefined,
+            signal: options.signal,
+        });
+        return parsed;
+    }
+}

package/index.d.ts

@@ -2,11 +2,30 @@ export { MaterialGraphClient, DEFAULT_BASE_URL, MAX_BATCH_IDS } from "./client.j
 export type { MaterialGraphClientOptions, BrowseNamespace } from "./client.js";
 export { MATERIALGRAPH_API_VERSION, SDK_OPERATIONS } from "./operations.js";
 export type { SdkOperation, SdkOperationId } from "./operations.js";
+export { TERMINAL_RUN_EVENT_TYPES } from "./run-types.js";
+export type * from "./run-types.js";
+export type * from "./schedule-types.js";
+export { VARY_AXES } from "./composition-types.js";
+export type * from "./composition-types.js";
+export { PROJECT_EVENT_KINDS } from "./project-types.js";
+export type * from "./project-types.js";
+export { COMPOSITION_PHASE_EVENT_TYPES, COMPOSITION_PROGRAMME_EVENT_TYPES, COMPOSITION_REVIEW_CRITERIA_EVENT_TYPES, parseRunEvent, } from "./run-events.js";
+export type * from "./run-events.js";
 export { MaterialGraphError } from "./errors.js";
 export type { MaterialGraphErrorInit, MaterialGraphErrorKind, MaterialGraphRequestMetadata, ProblemDetail, RateLimit, SanitizedErrorValue, SanitizedIssue, SimpleErrorBody, } from "./errors.js";
 export type * from "./types.js";
+export { MATCH_IMAGE_TYPES, MATCH_MATERIAL_FUNCTIONS, MATCH_STREAM_EVENT_TYPES, MATCH_SURFACE_STATUSES, MATCH_WORKFLOW_STEPS, } from "./match-stream-types.js";
+export type * from "./match-stream-types.js";
+export { CodesClient } from "./codes-client.js";
+export type * from "./codes-types.js";
+export { ColoursClient } from "./colours-client.js";
+export type { ColoursTransport } from "./colours-client.js";
+export type * from "./colour-aggregate-types.js";
 export type * from "./brand-types.js";
 export type * from "./material-asset-types.js";
 export type * from "./material-block-types.js";
 export type * from "./schema-resource-types.js";
 export type * from "./search-refinement-types.js";
+export { CERTIFICATION_PROGRAMME_ATTRIBUTE_ID } from "./spec-types.js";
+export type * from "./spec-types.js";
+export { certificationProgramme, certificationProgrammeCriterion, hasSpec, specCriterion, specTerm, } from "./specifications.js";

package/index.js

@@ -1,3 +1,12 @@
 export { MaterialGraphClient, DEFAULT_BASE_URL, MAX_BATCH_IDS } from "./client.js";
 export { MATERIALGRAPH_API_VERSION, SDK_OPERATIONS } from "./operations.js";
+export { TERMINAL_RUN_EVENT_TYPES } from "./run-types.js";
+export { VARY_AXES } from "./composition-types.js";
+export { PROJECT_EVENT_KINDS } from "./project-types.js";
+export { COMPOSITION_PHASE_EVENT_TYPES, COMPOSITION_PROGRAMME_EVENT_TYPES, COMPOSITION_REVIEW_CRITERIA_EVENT_TYPES, parseRunEvent, } from "./run-events.js";
 export { MaterialGraphError } from "./errors.js";
+export { MATCH_IMAGE_TYPES, MATCH_MATERIAL_FUNCTIONS, MATCH_STREAM_EVENT_TYPES, MATCH_SURFACE_STATUSES, MATCH_WORKFLOW_STEPS, } from "./match-stream-types.js";
+export { CodesClient } from "./codes-client.js";
+export { ColoursClient } from "./colours-client.js";
+export { CERTIFICATION_PROGRAMME_ATTRIBUTE_ID } from "./spec-types.js";
+export { certificationProgramme, certificationProgrammeCriterion, hasSpec, specCriterion, specTerm, } from "./specifications.js";