@asstio-dev/storefront 0.24.0 → 0.27.0

package/README.md

@@ -191,14 +191,39 @@ const { data: listing } = await storefront.GET("/v1/products", {
 });
 ```
 
+### Variant links
+
+A link to one variant is the product URL plus `?variant={variantId}` (the id from `variants[].id`); `variant.url` is
+that link ready-made, `null` when the variant has no price on the market. Read the parameter on the server, pass it
+to the API, and render by `selectedVariantStatus`:
+
+```ts
+const raw = (await headers()).get("x-search") ?? "";           // the raw search string, e.g. set by middleware
+const param = readVariantParam(raw);                   // absent | id | invalid
+const { data: product } = await storefront.GET("/v1/products/{slugOrId}", {
+  params: { path: { slugOrId: slug }, query: { variant: variantQueryForApi(param) } },
+});
+if (product?.redirectTo) permanentRedirect(redirectTarget(product.url!, raw));   // 308; keeps ?variant= and UTM as received
+// product.selectedVariantStatus: null (absent: your default), "matched" (preselect product.selectedVariant),
+// "notSoldHere" (show it as unavailable here, preselect nothing), "unknown" (note that it is gone, preselect nothing).
+if (!product) notFound();
+const ld = productJsonLd(product, { site, market: "se" });
+```
+
+Pass the **raw search string** to `readVariantParam` and `redirectTarget` when you can (for example from a
+middleware header): a Next.js `searchParams` record is accepted too, but it loses the interleaving of different keys.
+Canonical stays the product `url`. Never a 404 while the product resolves. If you have variant ids but no `v.url` (for example a cart line), `variantUrl(product.url, product.id, variantId)` builds the same link; the parameter name is exported as `VARIANT_PARAM`. The full contract is in the onboarding
+guide, "Variant links".
+
 ### SEO
 
 Pure helpers that compute schema.org JSON-LD and `<head>` data from the DTOs. They render nothing: your frontend
 writes the markup. No backend call, no DOM, no dependency.
 
 **Product JSON-LD.** `productJsonLd` returns a `Product` (one variant) or a `ProductGroup` with one `Product` and
-`Offer` per variant sold on the market. `variantUrl` is required: Google needs a distinct URL per variant, and opening
-that URL **must preselect the variant** on your page. The format is yours; `?variant=` below is only an example.
+`Offer` per variant sold on the market. Each variant's link is `v.url` from the API (see Variant links above), so no
+`variantUrl` hook is needed; pass one only to override it. Google needs a distinct URL per variant, and opening that
+URL **must preselect the variant** on your page. `productJsonLd` reads `product.selectedVariant` itself.
 `variesBy` maps your option names to `size`, `color`, `material` or `pattern`; unmapped options still name the
 variants. A product with more than 100 variants arrives with `variants: null`: pass the first `/variants` page as
 `variants`, or the product gets no offer (valid schema.org, but not eligible for product rich results).
@@ -206,7 +231,6 @@ variants. A product with more than 100 variants arrives with `variants: null`: p
 ```tsx
 const ld = productJsonLd(product, {
   site, market: "se",
-  variantUrl: (v) => `${product.url}?variant=${v.id}`,
   variesBy: { Storlek: "size", Färg: "color" },
 });
 <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: jsonLdScript(ld) }} />
@@ -237,7 +261,7 @@ export async function generateMetadata(): Promise<Metadata> {
 Titles come out as `{ absolute }` on purpose, so a layout's `title.template` does not apply a second time.
 
 **Errors.** `SeoError` means a caller or configuration error: `redirectTo` is set (answer 301 instead), an unknown
-market, a bad `variesBy` value, a `variantUrl` that is not an absolute http(s) URL or repeats for two variants, or
+market, a bad `variesBy` value, a variant URL (`v.url` or the optional `variantUrl` hook) that is missing, not an absolute http(s) URL or repeated for two variants, or
 two markets with the same `language-COUNTRY` and different URLs. Catch it at your SEO boundary and fix the market
 config. Holes in the data never throw: a missing image, description or price only leaves that part out.
 

package/dist/index.d.ts

@@ -61,3 +61,4 @@ export { longestCategory, toGa4Ecommerce, toGa4Item } from "./analytics/ga4.js";
 export { trackSearchEvents, type SearchEvent, type SearchEventsResponse } from "./analytics/events.js";
 export { AnalyticsError, type Ga4Ecommerce, type Ga4Item, type Ga4ItemOptions, type Ga4ItemSource, type Ga4Purchase, type Ga4SharedOptions, type ProductFacts, type SelectedVariant, } from "./analytics/types.js";
 export { SeoError, type BreadcrumbLink, type CollectionHeadOptions, type HeadOptions, type JsonLd, type NextMetadataLike, type ProductJsonLdOptions, type SchemaProperty, type SeoContext, type SeoHead, type SeoMeta, type VariantAvailability, } from "./seo/types.js";
+export { readVariantParam, redirectTarget, VARIANT_PARAM, variantQueryForApi, variantUrl, type QueryInput, type VariantParam, } from "./variant.js";

package/dist/index.js

@@ -50,3 +50,4 @@ export { longestCategory, toGa4Ecommerce, toGa4Item } from "./analytics/ga4.js";
 export { trackSearchEvents } from "./analytics/events.js";
 export { AnalyticsError, } from "./analytics/types.js";
 export { SeoError, } from "./seo/types.js";
+export { readVariantParam, redirectTarget, VARIANT_PARAM, variantQueryForApi, variantUrl, } from "./variant.js";

package/dist/schema.d.ts

@@ -546,6 +546,7 @@ export interface components {
             selectedOptions: {
                 [key: string]: string;
             };
+            url: null | string;
         };
         CategoryNodeDto: {
             children: components["schemas"]["CategoryNodeDto"][];
@@ -923,6 +924,7 @@ export interface components {
         };
         OrderLineVariantDto: {
             brand: null | components["schemas"]["BrandDto"];
+            url: null | string;
         };
         OrderShippingDto: {
             carrier: string;
@@ -1011,6 +1013,8 @@ export interface components {
             redirectTo: null | string;
             related: components["schemas"]["RelatedGroupDto"][];
             responsible: components["schemas"]["ResponsibleDto"];
+            selectedVariant: null | components["schemas"]["VariantDto"];
+            selectedVariantStatus: null | components["schemas"]["SelectedVariantStatus"];
             seo: components["schemas"]["SeoDto"];
             shortDescription: null | string;
             sku: string;
@@ -1099,6 +1103,8 @@ export interface components {
             name: string;
             slug: string;
         };
+        /** @enum {unknown} */
+        SelectedVariantStatus: "matched" | "notSoldHere" | "unknown";
         SellabilityDto: {
             mode: components["schemas"]["SiteSellabilityMode"];
         };
@@ -1255,6 +1261,7 @@ export interface components {
             };
             sku: string;
             stock: string;
+            url: null | string;
         };
         VariantOptionDto: {
             name: string;
@@ -3314,7 +3321,10 @@ export interface operations {
     };
     GetProduct: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description A variant id (`VariantDto.id`) to preselect. Answered in `selectedVariantStatus`; a value that is not one of this product's variants is `unknown`, never an error. */
+                variant?: string;
+            };
             header: {
                 /** @description Publishable, preview or secret site key. Required on every request; secret keys are server-side only. */
                 "X-Site-Key": string;

package/dist/seo/product.d.ts

@@ -1,6 +1,7 @@
 import { type JsonLd, type ProductDto, type ProductJsonLdOptions } from "./types.js";
 /**
  * schema.org `Product` / `ProductGroup` for a product page (spec §6.2). Decision order: no offer → single (only for a
- * proven singleton) → group. Never an `AggregateOffer`, never a guessed price.
+ * proven singleton) → group. Never an `AggregateOffer`, never a guessed price. A priced `p.selectedVariant` is always
+ * in the group, appended when the list does not hold it (variant URLs spec §6).
  */
 export declare function productJsonLd(p: ProductDto, ctx: ProductJsonLdOptions): JsonLd;

package/dist/seo/product.js

@@ -13,11 +13,14 @@ function availabilityOf(v, ctx) {
     return SCHEMA_AVAILABILITY[state] ?? OUT_OF_STOCK;
 }
 const brandNode = (label) => ({ "@type": "Brand", name: label });
-/** Spec §4.12: absolute http(s), distinct per variant; checked for every emitted variant, single path included. */
-function checkVariantUrls(variants, variantUrl) {
+/** Spec §4.12: absolute http(s), distinct per variant; checked for every emitted variant, single path included. The
+ * caller's hook wins, else the variant's own `url` (variant URLs spec §6); neither is an error. */
+function checkVariantUrls(variants, ctx) {
     const seen = new Set();
     return variants.map((v) => {
-        const u = variantUrl(v);
+        const u = ctx.variantUrl?.(v) ?? v.url;
+        if (u == null)
+            throw new SeoError(`variant ${v.sku} has no URL: neither the variantUrl hook nor v.url (from the API) gave one`);
         let parsed = null;
         if (typeof u === "string") {
             try {
@@ -57,7 +60,8 @@ function offerExtras(ctx) {
 }
 /**
  * schema.org `Product` / `ProductGroup` for a product page (spec §6.2). Decision order: no offer → single (only for a
- * proven singleton) → group. Never an `AggregateOffer`, never a guessed price.
+ * proven singleton) → group. Never an `AggregateOffer`, never a guessed price. A priced `p.selectedVariant` is always
+ * in the group, appended when the list does not hold it (variant URLs spec §6).
  */
 export function productJsonLd(p, ctx) {
     rejectRedirect(p, `product ${p.sku}`);
@@ -66,19 +70,24 @@ export function productJsonLd(p, ctx) {
     for (const [axis, prop] of Object.entries(variesBy))
         if (!PROPERTIES.includes(prop))
             throw new SeoError(`variesBy['${axis}'] = '${prop}' is not one of ${PROPERTIES.join(", ")}`);
-    if (typeof ctx.variantUrl !== "function")
-        throw new SeoError("variantUrl is required: Google needs a distinct URL that preselects each variant");
+    if (ctx.variantUrl !== undefined && typeof ctx.variantUrl !== "function")
+        throw new SeoError("variantUrl must be a function");
     const list = p.variants ?? ctx.variants ?? null;
     const complete = p.variants !== null;
-    const sellable = (list ?? []).filter((v) => v.price !== null);
+    // Variant URLs spec §6: a priced selection is always emitted, exactly once (deduplicated by id against the list).
+    const sel = p.selectedVariant?.price != null ? p.selectedVariant : null;
+    const merged = sel !== null && !(list ?? []).some((v) => v.id === sel.id) ? [...(list ?? []), sel] : (list ?? []);
+    const sellable = merged.filter((v) => v.price !== null);
     const description = jsonLdDescription(productDescription(p));
     const images = pickImages(ctx.site, p.images, market.language, p.name).map((i) => i.url);
-    const common = (type) => ({
+    // Variant URLs spec §5.4: effective images = the variant's own set when it owns one (an owned empty set stays empty).
+    const effectiveImages = (v, alt) => v.hasOwnImages ? pickImages(ctx.site, v.images, market.language, alt).map((x) => x.url) : images;
+    const common = (type, image = images) => ({
         "@context": "https://schema.org",
         "@type": type,
         name: p.name,
         ...(description !== null ? { description } : {}),
-        ...(images.length > 0 ? { image: images } : {}),
+        ...(image.length > 0 ? { image } : {}),
         url: p.url,
     });
     const offer = (v, url) => ({
@@ -98,14 +107,16 @@ export function productJsonLd(p, ctx) {
         const keyed = gtinJsonLd(g);
         return Object.keys(keyed).length > 0 ? keyed : { gtin: g };
     };
-    if (list === null || sellable.length === 0)
+    if (sellable.length === 0)
         return { ...common("Product"), sku: p.sku, ...(p.brand ? { brand: brandNode(p.brand.label) } : {}) };
-    if (list.length === 1 && p.options.length === 0 && sellable.length === 1 && (complete || Number(p.variantCount) === 1)) {
-        const v = sellable[0];
-        const [url] = checkVariantUrls([v], ctx.variantUrl);
-        return { ...common("Product"), sku: v.sku, ...gtin(v), ...(v.brand ? { brand: brandNode(v.brand.label) } : {}), offers: offer(v, url) };
+    // The singleton is decided on the list alone: a selection never turns a proven singleton into a group (§6).
+    const listSellable = (list ?? []).filter((v) => v.price !== null);
+    if (list !== null && list.length === 1 && p.options.length === 0 && listSellable.length === 1 && (complete || Number(p.variantCount) === 1)) {
+        const v = listSellable[0];
+        const [url] = checkVariantUrls([v], ctx);
+        return { ...common("Product", effectiveImages(v, p.name)), sku: v.sku, ...gtin(v), ...(v.brand ? { brand: brandNode(v.brand.label) } : {}), offers: offer(v, url) };
     }
-    const urls = checkVariantUrls(sellable, ctx.variantUrl);
+    const urls = checkVariantUrls(sellable, ctx);
     // Spec §4.14: hoist only from the DTO's own list, and only when every emitted variant has the same non-null label.
     const first = sellable[0].brand?.label;
     const hoisted = complete && first != null && sellable.every((v) => v.brand?.label === first) ? first : null;
@@ -113,7 +124,8 @@ export function productJsonLd(p, ctx) {
     const props = [...new Set(axes.map((a) => a.prop))];
     return {
         ...common("ProductGroup"),
-        productGroupID: p.sku,
+        // VU8: the product id, which never changes and matches the feeds' item_group_id; a SKU can be renamed.
+        productGroupID: p.id,
         ...(props.length > 0 ? { variesBy: props.map((x) => `https://schema.org/${x}`) } : {}),
         ...(hoisted !== null ? { brand: brandNode(hoisted) } : {}),
         hasVariant: sellable.map((v, i) => {
@@ -124,13 +136,13 @@ export function productJsonLd(p, ctx) {
                 if (value !== undefined && !Object.hasOwn(own, a.prop))
                     own[a.prop] = value;
             }
-            const vImages = v.hasOwnImages ? pickImages(ctx.site, v.images, market.language, name).map((x) => x.url) : [];
+            const vImages = effectiveImages(v, name);
             return {
                 "@type": "Product",
                 sku: v.sku,
                 ...gtin(v),
                 name,
-                inProductGroupWithID: p.sku,
+                inProductGroupWithID: p.id,
                 ...own,
                 ...(vImages.length > 0 ? { image: vImages } : {}),
                 ...(hoisted === null && v.brand ? { brand: brandNode(v.brand.label) } : {}),

package/dist/seo/types.d.ts

@@ -36,8 +36,9 @@ export type SeoHead = {
     meta: SeoMeta[];
 };
 export type ProductJsonLdOptions = SeoContext & {
-    /** Required: a distinct absolute http(s) URL that opens the page with this variant preselected (spec §4.12). */
-    variantUrl: (v: VariantDto) => string;
+    /** A distinct absolute http(s) URL that opens the page with this variant preselected (spec §4.12). Optional: defaults
+     * to the variant's own `url` (variant URLs spec §6); a hook given here wins. */
+    variantUrl?: (v: VariantDto) => string;
     /** Option name (`options[].name`) → schema.org property, e.g. `{ Storlek: "size", Färg: "color" }`. */
     variesBy?: Record<string, SchemaProperty>;
     /** Used only when `p.variants` is `null` (more than 100 variants), e.g. the first page of `/variants`. */

package/dist/variant.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Variant URL helpers (spec 2026-10-16 §4, §7, §8 step 2). The selector is the query parameter `variant`; its key is the
+ * variant id exactly as `VariantDto.id` returns it. A frontend builds, reads and redirects with these, never by hand.
+ */
+/** The fixed name of the variant selector parameter (VU3). */
+export declare const VARIANT_PARAM = "variant";
+/** What a request's `variant` parameter says: nothing, one numeric id, or anything else (empty, text, repeated). */
+export type VariantParam = {
+    kind: "absent";
+} | {
+    kind: "invalid";
+    raw: string[];
+} | {
+    kind: "id";
+    value: string;
+};
+/**
+ * A received query. A `string` is a raw search (`"?a=1&b=2"` or `"a=1&b=2"`) and is the only form that keeps the
+ * interleaving of different keys; a record is the Next.js `searchParams` shape.
+ */
+export type QueryInput = string | URLSearchParams | Record<string, string | string[] | undefined>;
+/** The URL of one variant: the product URL with `variant=<id>` set by query handling (VU6: the product URL when the ids match).
+ * Prefer `v.url` when you have it: equal in meaning, not always byte-equal (the query is re-serialized). */
+export declare function variantUrl(productUrl: string, productId: string, variantId: string): string;
+/** Read the selector: every `variant` value in order; exactly one all-digit value is an id, anything else is invalid. */
+export declare function readVariantParam(q: QueryInput): VariantParam;
+/** The value to send as the API's `variant` query parameter: the id, `"-"` for an invalid selector, none when absent. */
+export declare function variantQueryForApi(parsed: VariantParam): string | undefined;
+/**
+ * Where a 301 to `destinationUrl` should point: the destination's path and query, plus every received parameter the
+ * destination does not set itself (destination wins), in incoming order and multiplicity. `variant` is always carried
+ * as received. Values are decoded and re-encoded (`a%20b` becomes `a+b`): names, values, multiplicity and order are kept.
+ */
+export declare function redirectTarget(destinationUrl: string, received: QueryInput): string;

package/dist/variant.js

@@ -0,0 +1,71 @@
+/**
+ * Variant URL helpers (spec 2026-10-16 §4, §7, §8 step 2). The selector is the query parameter `variant`; its key is the
+ * variant id exactly as `VariantDto.id` returns it. A frontend builds, reads and redirects with these, never by hand.
+ */
+/** The fixed name of the variant selector parameter (VU3). */
+export const VARIANT_PARAM = "variant";
+// The API's key policy: a key equals `variant` ASCII case-insensitively.
+const isVariantKey = (k) => k.toLowerCase() === VARIANT_PARAM;
+function entries(q) {
+    if (typeof q === "string")
+        return [...new URLSearchParams(q.startsWith("?") ? q.slice(1) : q)];
+    if (q instanceof URLSearchParams)
+        return [...q];
+    const out = [];
+    for (const [k, v] of Object.entries(q)) {
+        if (v === undefined)
+            continue;
+        for (const item of Array.isArray(v) ? v : [v])
+            out.push([k, item]);
+    }
+    return out;
+}
+/** The URL of one variant: the product URL with `variant=<id>` set by query handling (VU6: the product URL when the ids match).
+ * Prefer `v.url` when you have it: equal in meaning, not always byte-equal (the query is re-serialized). */
+export function variantUrl(productUrl, productId, variantId) {
+    if (variantId === productId)
+        return productUrl;
+    const url = new URL(productUrl);
+    for (const k of [...new Set([...url.searchParams.keys()])])
+        if (isVariantKey(k))
+            url.searchParams.delete(k);
+    url.searchParams.append(VARIANT_PARAM, variantId);
+    return url.toString();
+}
+/** Read the selector: every `variant` value in order; exactly one all-digit value is an id, anything else is invalid. */
+export function readVariantParam(q) {
+    const raw = entries(q).filter(([k]) => isVariantKey(k)).map(([, v]) => v);
+    if (raw.length === 0)
+        return { kind: "absent" };
+    if (raw.length === 1 && /^\d{1,19}$/.test(raw[0]))
+        return { kind: "id", value: raw[0] };
+    return { kind: "invalid", raw };
+}
+/** The value to send as the API's `variant` query parameter: the id, `"-"` for an invalid selector, none when absent. */
+export function variantQueryForApi(parsed) {
+    switch (parsed.kind) {
+        case "id": return parsed.value;
+        case "invalid": return "-";
+        default: return undefined;
+    }
+}
+/**
+ * Where a 301 to `destinationUrl` should point: the destination's path and query, plus every received parameter the
+ * destination does not set itself (destination wins), in incoming order and multiplicity. `variant` is always carried
+ * as received. Values are decoded and re-encoded (`a%20b` becomes `a+b`): names, values, multiplicity and order are kept.
+ */
+export function redirectTarget(destinationUrl, received) {
+    const dest = new URL(destinationUrl);
+    const own = new Set(dest.searchParams.keys());
+    const out = new URLSearchParams();
+    for (const [k, v] of dest.searchParams)
+        if (!isVariantKey(k))
+            out.append(k, v);
+    for (const [k, v] of entries(received))
+        if (isVariantKey(k) || !own.has(k))
+            out.append(k, v);
+    const search = out.toString();
+    // A path starting with `//` would read as protocol-relative; keep one slash.
+    const path = dest.pathname.replace(/^\/{2,}/, "/");
+    return path + (search ? "?" + search : "");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asstio-dev/storefront",
-  "version": "0.24.0",
+  "version": "0.27.0",
   "description": "Typed client for the Asstio Storefront API (generated from OpenAPI).",
   "repository": {
     "type": "git",
@@ -21,7 +21,7 @@
     "test": "vitest run",
     "test:browser": "playwright test -c browser/playwright.config.ts",
     "check": "npm run generate && npm run typecheck-examples && npm test && git diff --exit-code -- src/schema.d.ts && test -z \"$(git status --porcelain -- src/schema.d.ts)\"",
-    "smoke": "node --input-type=module -e \"import(\\\"./dist/index.js\\\").then(m => { for (const f of [\\\"createStorefrontClient\\\", \\\"filterQuery\\\", \\\"encodeFilterValues\\\", \\\"decodeFilterValues\\\", \\\"pictureSources\\\", \\\"mediaUrl\\\", \\\"formatImage\\\", \\\"styleToCss\\\", \\\"startCheckout\\\", \\\"syncCheckout\\\", \\\"completeCheckout\\\", \\\"getCheckoutStatus\\\", \\\"liveShippingFor\\\", \\\"getOrder\\\", \\\"awaitCompletion\\\", \\\"mountCheckout\\\", \\\"productJsonLd\\\", \\\"gtinJsonLd\\\", \\\"breadcrumbJsonLd\\\", \\\"productHead\\\", \\\"collectionHead\\\", \\\"brandHead\\\", \\\"toNextMetadata\\\", \\\"jsonLdScript\\\", \\\"SeoError\\\", \\\"productFacts\\\", \\\"toGa4Item\\\", \\\"toGa4Ecommerce\\\", \\\"longestCategory\\\", \\\"AnalyticsError\\\", \\\"trackSearchEvents\\\"]) if (typeof m[f] !== \\\"function\\\") throw new Error(\\\"missing export \\\" + f) })\""
+    "smoke": "node --input-type=module -e \"import(\\\"./dist/index.js\\\").then(m => { for (const f of [\\\"createStorefrontClient\\\", \\\"filterQuery\\\", \\\"encodeFilterValues\\\", \\\"decodeFilterValues\\\", \\\"pictureSources\\\", \\\"mediaUrl\\\", \\\"formatImage\\\", \\\"styleToCss\\\", \\\"startCheckout\\\", \\\"syncCheckout\\\", \\\"completeCheckout\\\", \\\"getCheckoutStatus\\\", \\\"liveShippingFor\\\", \\\"getOrder\\\", \\\"awaitCompletion\\\", \\\"mountCheckout\\\", \\\"productJsonLd\\\", \\\"gtinJsonLd\\\", \\\"breadcrumbJsonLd\\\", \\\"productHead\\\", \\\"collectionHead\\\", \\\"brandHead\\\", \\\"toNextMetadata\\\", \\\"jsonLdScript\\\", \\\"SeoError\\\", \\\"productFacts\\\", \\\"toGa4Item\\\", \\\"toGa4Ecommerce\\\", \\\"longestCategory\\\", \\\"AnalyticsError\\\", \\\"trackSearchEvents\\\", \\\"variantUrl\\\", \\\"readVariantParam\\\", \\\"variantQueryForApi\\\", \\\"redirectTarget\\\"]) if (typeof m[f] !== \\\"function\\\") throw new Error(\\\"missing export \\\" + f) })\""
   },
   "dependencies": {
     "openapi-fetch": "0.17.0"

package/src/schema.d.ts

@@ -546,6 +546,7 @@ export interface components {
             selectedOptions: {
                 [key: string]: string;
             };
+            url: null | string;
         };
         CategoryNodeDto: {
             children: components["schemas"]["CategoryNodeDto"][];
@@ -923,6 +924,7 @@ export interface components {
         };
         OrderLineVariantDto: {
             brand: null | components["schemas"]["BrandDto"];
+            url: null | string;
         };
         OrderShippingDto: {
             carrier: string;
@@ -1011,6 +1013,8 @@ export interface components {
             redirectTo: null | string;
             related: components["schemas"]["RelatedGroupDto"][];
             responsible: components["schemas"]["ResponsibleDto"];
+            selectedVariant: null | components["schemas"]["VariantDto"];
+            selectedVariantStatus: null | components["schemas"]["SelectedVariantStatus"];
             seo: components["schemas"]["SeoDto"];
             shortDescription: null | string;
             sku: string;
@@ -1099,6 +1103,8 @@ export interface components {
             name: string;
             slug: string;
         };
+        /** @enum {unknown} */
+        SelectedVariantStatus: "matched" | "notSoldHere" | "unknown";
         SellabilityDto: {
             mode: components["schemas"]["SiteSellabilityMode"];
         };
@@ -1255,6 +1261,7 @@ export interface components {
             };
             sku: string;
             stock: string;
+            url: null | string;
         };
         VariantOptionDto: {
             name: string;
@@ -3314,7 +3321,10 @@ export interface operations {
     };
     GetProduct: {
         parameters: {
-            query?: never;
+            query?: {
+                /** @description A variant id (`VariantDto.id`) to preselect. Answered in `selectedVariantStatus`; a value that is not one of this product's variants is `unknown`, never an error. */
+                variant?: string;
+            };
             header: {
                 /** @description Publishable, preview or secret site key. Required on every request; secret keys are server-side only. */
                 "X-Site-Key": string;