@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/catalog/reviews.js

@@ -0,0 +1,318 @@
+/**
+ * Product reviews (headless spec §9.2 `catalog`: "reviews moderation"; W10-117): the reviews the
+ * store's customers wrote, moderating them (what the storefront shows under the store's name),
+ * the store's reply to one, the review statistics, and the review attributes (the questions a
+ * review form asks: "Quality", "Fit", …).
+ *
+ * - **What the storefront shows**: only `APPROVED` reviews, with the reviewer's display name,
+ *   rating, title, text, attribute answers and the store's reply. `PENDING` (waiting), `FLAGGED`
+ *   (the automatic checks or a shopper's report asked for a look) and `REJECTED` reviews are never
+ *   shown. Approving publishes the review; rejecting, flagging or re-opening it (`PENDING`) takes it
+ *   off. Each moderation is recorded in the review's moderation log with the staff member and the
+ *   reason given.
+ * - **The reply** is the store's own text, shown under an approved review on the storefront.
+ *
+ * Customer data (headless spec §6.3): an app installation below `customerData: full` reads every
+ * review with what the customer typed blanked: `title`, `body`, `attributeValues` (ratings and
+ * self-declared details such as an age band) and `ipAddressHash`, the edit history's previous
+ * texts and the moderation log's reasons and AI analysis answer `null`, and so does
+ * `customerDisplayName` below `identity`. Every record of such an answer carries `redacted: true`,
+ * so a blanked field never reads as "the customer wrote none". A `search` below `full` is refused
+ * `CUSTOMER_DATA_NOT_GRANTED` (`PermissionDeniedError`, 403). The answers of the writes are
+ * blanked the same way.
+ *
+ * Permissions: reads need `ReadCatalog`, writes `UpdateCatalog`. Every row is the store's own: a
+ * review or attribute of another store is never answered and never changed.
+ *
+ * Refusals, GraphQL errors mapped by `core`. An unknown id and another store's get the same
+ * answer, so none tells whether another store holds the row:
+ * - `ENTITY_NOT_FOUND` → `NotFoundError` (404): a review or attribute the store does not have. An
+ *   id that is not a uuid gets it too, before anything is read.
+ * - `REVIEW_ATTRIBUTE_SLUG_TAKEN` → `ConflictError` (409): another of the store's attributes holds
+ *   the slug, the one derived from the label included, also when two writes race for it.
+ * - `REVIEW_ATTRIBUTE_COLLECTION_NOT_FOUND` → `NotFoundError` (404): `attributes.setCollections`
+ *   named a collection the store does not hold, each in `details` (`field` `/collectionIds/<i>`).
+ * - `BULK_ACTION_INPUT_INVALID` → `ValidationError` (400): a `bulkModerate` selection of no
+ *   review, more than {@link MAX_BULK_REVIEWS} or one twice, refused before anything is sent.
+ * - `USER_INPUT_ERROR` → `ValidationError` (400), in the engine's words: a reply over 2,000
+ *   characters, an attribute type other than `rating` / `selection`, a selection with fewer than
+ *   two options.
+ * - `FORBIDDEN` → `PermissionDeniedError` (403) without the permission.
+ *
+ * Release: `bulkModerate` needs a platform release with `moderateReviews` (deploy vendure-server
+ * first: an older one refuses the document). Every other method is served by every release this
+ * SDK supports; an older release answers each not-found and a taken slug as `USER_INPUT_ERROR`
+ * (400), a taken slug as an uncoded database error, and takes another store's collection in
+ * `setCollections`. No method deduplicates on `idempotencyKey`.
+ */
+import { pageFromVendureList, readOffsetCursor, UpstreamError, ValidationError, } from '@sixtyninecommerce/core';
+import { redactionWatcher } from '../customer-data-redaction.js';
+import { assertDeleted, DELETION_FIELDS, fieldOf } from './types.js';
+export const REVIEW_STATUSES = [
+    'PENDING',
+    'APPROVED',
+    'REJECTED',
+    'FLAGGED',
+];
+/** How many reviews one list page holds at most: the engine answers no more. */
+export const MAX_REVIEW_PAGE_SIZE = 50;
+/** How many reviews one `bulkModerate` call may name. */
+export const MAX_BULK_REVIEWS = 100;
+const REVIEW_FIELDS = /* GraphQL */ `
+  id
+  channelId
+  customerId
+  productId
+  productName
+  variantId
+  rating
+  title
+  body
+  status
+  isVerifiedPurchase
+  purchaseDate
+  deliveryDate
+  isEdited
+  editCount
+  customerDisplayName
+  imageAssetIds
+  videoAssetIds
+  attributeValues
+  helpfulCount
+  notHelpfulCount
+  merchantReply
+  merchantReplyAt
+  ipAddressHash
+  createdAt
+  updatedAt
+`;
+const REVIEW_DETAIL_FIELDS = /* GraphQL */ `
+  ${REVIEW_FIELDS}
+  editHistory {
+    id
+    previousRating
+    previousTitle
+    previousBody
+    previousAttributeValues
+    editedAt
+    reEnteredModeration
+    createdAt
+  }
+  moderationLogs {
+    id
+    step
+    action
+    reason
+    confidence
+    aiAnalysis
+    performedBy
+    tokenUsage
+    createdAt
+  }
+`;
+const ATTRIBUTE_FIELDS = /* GraphQL */ `
+  id
+  slug
+  label
+  inputType
+  options
+  isRequired
+  enabled
+  section
+  position
+  collectionIds
+  createdAt
+  updatedAt
+`;
+export const PRODUCT_REVIEWS_QUERY = /* GraphQL */ `
+  query CatalogProductReviews($options: AdminReviewListOptions) {
+    adminProductReviews(options: $options) {
+      items { ${REVIEW_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const PRODUCT_REVIEW_QUERY = /* GraphQL */ `
+  query CatalogProductReview($id: ID!) {
+    adminProductReview(id: $id) { ${REVIEW_DETAIL_FIELDS} }
+  }
+`;
+export const REVIEW_STATS_QUERY = /* GraphQL */ `
+  query CatalogReviewStats {
+    reviewStats {
+      totalReviews
+      pendingCount
+      approvedCount
+      rejectedCount
+      flaggedCount
+      averageRating
+      ratingsThisWeek
+      ratingsThisMonth
+    }
+  }
+`;
+export const MODERATE_REVIEW_MUTATION = /* GraphQL */ `
+  mutation CatalogModerateReview($id: ID!, $action: ReviewStatus!, $reason: String) {
+    moderateReview(id: $id, action: $action, reason: $reason) { ${REVIEW_FIELDS} }
+  }
+`;
+export const MODERATE_REVIEWS_MUTATION = /* GraphQL */ `
+  mutation CatalogModerateReviews($input: ModerateReviewsInput!) {
+    moderateReviews(input: $input) {
+      items { id status code message }
+    }
+  }
+`;
+export const SET_MERCHANT_REPLY_MUTATION = /* GraphQL */ `
+  mutation CatalogSetMerchantReply($reviewId: ID!, $reply: String!) {
+    setMerchantReply(reviewId: $reviewId, reply: $reply) { ${REVIEW_FIELDS} }
+  }
+`;
+export const REMOVE_MERCHANT_REPLY_MUTATION = /* GraphQL */ `
+  mutation CatalogRemoveMerchantReply($reviewId: ID!) {
+    removeMerchantReply(reviewId: $reviewId) { ${REVIEW_FIELDS} }
+  }
+`;
+export const REVIEW_ATTRIBUTES_QUERY = /* GraphQL */ `
+  query CatalogReviewAttributes {
+    adminReviewAttributes { ${ATTRIBUTE_FIELDS} }
+  }
+`;
+export const CREATE_REVIEW_ATTRIBUTE_MUTATION = /* GraphQL */ `
+  mutation CatalogCreateReviewAttribute($input: AdminReviewAttributeInput!) {
+    createReviewAttribute(input: $input) { ${ATTRIBUTE_FIELDS} }
+  }
+`;
+export const UPDATE_REVIEW_ATTRIBUTE_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdateReviewAttribute($id: ID!, $input: UpdateReviewAttributeInput!) {
+    updateReviewAttribute(id: $id, input: $input) { ${ATTRIBUTE_FIELDS} }
+  }
+`;
+export const DELETE_REVIEW_ATTRIBUTE_MUTATION = /* GraphQL */ `
+  mutation CatalogDeleteReviewAttribute($id: ID!) {
+    deleteReviewAttribute(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const REORDER_REVIEW_ATTRIBUTES_MUTATION = /* GraphQL */ `
+  mutation CatalogReorderReviewAttributes($ids: [ID!]!) {
+    reorderReviewAttributes(ids: $ids) { ${ATTRIBUTE_FIELDS} }
+  }
+`;
+export const SET_REVIEW_ATTRIBUTE_COLLECTIONS_MUTATION = /* GraphQL */ `
+  mutation CatalogSetReviewAttributeCollections($attributeId: ID!, $collectionIds: [ID!]!) {
+    setReviewAttributeCollections(attributeId: $attributeId, collectionIds: $collectionIds) {
+      ${ATTRIBUTE_FIELDS}
+    }
+  }
+`;
+function unexpected(field) {
+    return new UpstreamError({
+        code: 'UNEXPECTED_RESPONSE',
+        message: `The engine answered without "${field}".`,
+        status: 502,
+        service: 'vendure',
+    });
+}
+function invalid(code, message) {
+    return new ValidationError({ code, message, status: 400, service: 'vendure' });
+}
+/** Attributes in `position` order, the older first on a tie (the engine orders by position only). */
+function byPosition(attributes) {
+    return [...attributes].sort((a, b) => a.position - b.position || a.createdAt.localeCompare(b.createdAt));
+}
+/** The selection of a bulk call, checked as the engine checks it, before anything is sent. */
+function bulkVariables(input) {
+    const refused = (message) => invalid('BULK_ACTION_INPUT_INVALID', message);
+    if (typeof input !== 'object' || input === null) {
+        throw refused('A bulk moderation needs ids and an action.');
+    }
+    if (!REVIEW_STATUSES.includes(input.action)) {
+        throw refused(`action must be one of ${REVIEW_STATUSES.join(', ')}.`);
+    }
+    const ids = input.ids;
+    if (!Array.isArray(ids) || !ids.every((id) => typeof id === 'string')) {
+        throw refused('ids must be a list of strings.');
+    }
+    if (ids.length === 0)
+        throw refused('Name at least one review.');
+    if (ids.length > MAX_BULK_REVIEWS) {
+        throw refused(`A bulk moderation takes at most ${String(MAX_BULK_REVIEWS)} reviews.`);
+    }
+    if (new Set(ids.map((id) => id.toLowerCase())).size !== ids.length) {
+        throw refused('Name each review once.');
+    }
+    return {
+        input: {
+            ids: [...ids],
+            action: input.action,
+            ...(input.reason === undefined ? {} : { reason: input.reason }),
+        },
+    };
+}
+export function createReviewsModule(transport) {
+    async function reviewCall(document, field, variables, options, nullable = false) {
+        const redaction = redactionWatcher();
+        const data = await transport.graphql({ api: 'admin', query: document, variables, onExtensions: redaction.onExtensions }, options);
+        if (data === null || typeof data !== 'object' || !Object.hasOwn(data, field)) {
+            throw unexpected(field);
+        }
+        const review = data[field] ?? null;
+        if (review === null && !nullable)
+            throw unexpected(field);
+        return review === null ? null : redaction.mark(review);
+    }
+    async function reviewsPage(filters, skip, take, call) {
+        const redaction = redactionWatcher();
+        const data = await transport.graphql({
+            api: 'admin',
+            query: PRODUCT_REVIEWS_QUERY,
+            variables: { options: { ...filters, skip, take } },
+            onExtensions: redaction.onExtensions,
+        }, call);
+        const list = data?.adminProductReviews;
+        if (!list)
+            throw unexpected('adminProductReviews');
+        return pageFromVendureList({ items: list.items.map((review) => redaction.mark(review)), totalItems: list.totalItems }, skip, take, (cursor) => reviewsPage(filters, readOffsetCursor(cursor), take, call));
+    }
+    return {
+        // `async`: a refused option rejects the promise, as an engine refusal does.
+        async list(options) {
+            const { status, productId, customerId, search, rating, sort, limit, after, ...call } = options ?? {};
+            const take = limit ?? 25;
+            if (!Number.isInteger(take) || take < 1 || take > MAX_REVIEW_PAGE_SIZE) {
+                throw invalid('INVALID_PAGE_SIZE', `limit must be a whole number from 1 to ${String(MAX_REVIEW_PAGE_SIZE)}; got ${String(take)}.`);
+            }
+            const filters = Object.fromEntries(Object.entries({ status, productId, customerId, search, rating, sort }).filter(([, value]) => value !== undefined && value !== ''));
+            return reviewsPage(filters, after === undefined ? 0 : readOffsetCursor(after), take, call);
+        },
+        get: (id, options) => reviewCall(PRODUCT_REVIEW_QUERY, 'adminProductReview', { id }, options, true),
+        async stats(options) {
+            const stats = await fieldOf(transport, REVIEW_STATS_QUERY, 'reviewStats', {}, options);
+            if (stats === null)
+                throw unexpected('reviewStats');
+            return stats;
+        },
+        moderate: (id, input, options) => reviewCall(MODERATE_REVIEW_MUTATION, 'moderateReview', { id, action: input.action, reason: input.reason ?? null }, options),
+        async bulkModerate(input, options) {
+            const data = await fieldOf(transport, MODERATE_REVIEWS_MUTATION, 'moderateReviews', bulkVariables(input), options);
+            if (data === null)
+                throw unexpected('moderateReviews');
+            return data.items;
+        },
+        reply: {
+            set: (reviewId, reply, options) => reviewCall(SET_MERCHANT_REPLY_MUTATION, 'setMerchantReply', { reviewId, reply }, options),
+            remove: (reviewId, options) => reviewCall(REMOVE_MERCHANT_REPLY_MUTATION, 'removeMerchantReply', { reviewId }, options),
+        },
+        attributes: {
+            list: async (options) => byPosition(await fieldOf(transport, REVIEW_ATTRIBUTES_QUERY, 'adminReviewAttributes', {}, options)),
+            create: (input, options) => fieldOf(transport, CREATE_REVIEW_ATTRIBUTE_MUTATION, 'createReviewAttribute', { input }, options),
+            update: (id, input, options) => fieldOf(transport, UPDATE_REVIEW_ATTRIBUTE_MUTATION, 'updateReviewAttribute', { id, input }, options),
+            async delete(id, options) {
+                const response = await fieldOf(transport, DELETE_REVIEW_ATTRIBUTE_MUTATION, 'deleteReviewAttribute', { id }, options);
+                assertDeleted('REVIEW_ATTRIBUTE_NOT_DELETED', [response]);
+            },
+            reorder: async (ids, options) => byPosition(await fieldOf(transport, REORDER_REVIEW_ATTRIBUTES_MUTATION, 'reorderReviewAttributes', { ids }, options)),
+            setCollections: (attributeId, collectionIds, options) => fieldOf(transport, SET_REVIEW_ATTRIBUTE_COLLECTIONS_MUTATION, 'setReviewAttributeCollections', { attributeId, collectionIds }, options),
+        },
+    };
+}

package/dist/catalog/types.d.ts

@@ -9,7 +9,23 @@ export interface AssetRef {
     /** A preview URL the asset server scales; absolute or relative to the engine. */
     preview: string;
     source: string;
+    /** A string on the wire: a newer engine may add a type. */
+    type: 'IMAGE' | 'VIDEO' | 'BINARY' | (string & {});
+    mimeType: string;
+    /**
+     * The image's alt text: the store's default-language description
+     * (`catalog.assets.descriptions`); null when it has none.
+     */
+    altText: string | null;
+}
+/** An {@link AssetRef} as the Admin API answers it, before {@link toAssetRef}. */
+export interface WireAssetRef extends Omit<AssetRef, 'altText'> {
+    customFields: {
+        altText?: string | null;
+    } | null;
 }
+/** Lift the alt text out of the asset's custom fields. */
+export declare function toAssetRef(wire: WireAssetRef): AssetRef;
 export interface FacetValueRef {
     id: string;
     code: string;
@@ -121,7 +137,7 @@ export interface CatalogueOwnership {
 }
 /** `catalogueOwnership` on the top-level row of each catalogue read (never on nested refs). */
 export declare const CATALOGUE_OWNERSHIP_FIELDS = "\n  catalogueOwnership {\n    state\n    organizationName\n    editableHere\n  }\n";
-export declare const ASSET_REF_FIELDS = "\n  id\n  name\n  preview\n  source\n";
+export declare const ASSET_REF_FIELDS = "\n  id\n  name\n  preview\n  source\n  type\n  mimeType\n  customFields {\n    altText\n  }\n";
 export declare const FACET_VALUE_REF_FIELDS = "\n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n";
 /**
  * Refuse a datetime with no offset, or one that is not a date at all (spec

package/dist/catalog/types.js

@@ -1,4 +1,9 @@
 import { ConflictError, errorFromErrorResult, isErrorResult, pageFromVendureList, readOffsetCursor, UpstreamError, ValidationError, } from '@sixtyninecommerce/core';
+/** Lift the alt text out of the asset's custom fields. */
+export function toAssetRef(wire) {
+    const { customFields, ...rest } = wire;
+    return { ...rest, altText: customFields?.altText ?? null };
+}
 /** `catalogueOwnership` on the top-level row of each catalogue read (never on nested refs). */
 export const CATALOGUE_OWNERSHIP_FIELDS = /* GraphQL */ `
   catalogueOwnership {
@@ -12,6 +17,11 @@ export const ASSET_REF_FIELDS = /* GraphQL */ `
   name
   preview
   source
+  type
+  mimeType
+  customFields {
+    altText
+  }
 `;
 export const FACET_VALUE_REF_FIELDS = /* GraphQL */ `
   id

package/dist/catalog/variant-find.d.ts

@@ -0,0 +1,136 @@
+import { type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+import type { InventoryFlag, VariantStorePrice } from './variants.js';
+/** The most variants one `variants.find` answers. */
+export declare const MAX_VARIANT_FIND_TAKE = 500;
+/** The most products one `variants.find` search reads (`take / perProduct`, rounded up). */
+export declare const MAX_VARIANT_FIND_PRODUCTS = 100;
+/** Which variants `variants.find` answers: exactly one of `ids`, `term` and `skuPrefix`. */
+export interface FindVariantsInput {
+    /**
+     * Exactly these variants, in the order asked. An id the store does not hold (another store's,
+     * a deleted variant, a hidden carrier variant) is left out, never an error; a repeated id is
+     * answered once. More than `take` distinct ids is refused.
+     */
+    ids?: readonly string[];
+    /**
+     * Full text over the store's product index (a product's name, SKUs, slug, variant names and
+     * description): the variants of the best-matching products, best product first.
+     */
+    term?: string;
+    /**
+     * The products that have a SKU starting with this text, by name, and of each the variants
+     * whose own SKU starts with it. Capitals do not matter.
+     */
+    skuPrefix?: string;
+    /** The most variants the answer holds, 1 to {@link MAX_VARIANT_FIND_TAKE}. */
+    take: number;
+    /**
+     * A search only: the most variants of ONE product, so a product line of thousands cannot fill
+     * the answer. From 1 to `take`; a tenth of `take`, rounded up, when omitted. The search reads
+     * the best `take / perProduct` products (rounded up, at most
+     * {@link MAX_VARIANT_FIND_PRODUCTS}).
+     */
+    perProduct?: number;
+    /**
+     * Price the variants in this currency. The store's default when omitted. The engine refuses a
+     * currency the store does not sell.
+     */
+    currencyCode?: string;
+}
+/** A found variant's stock at one of the store's locations. */
+export interface FoundVariantStockLevel {
+    stockLocationId: string;
+    stockLocationName: string;
+    stockOnHand: number;
+    /** Units open orders have reserved there. */
+    stockAllocated: number;
+}
+/** The product a found variant belongs to. */
+export interface FoundVariantProduct {
+    id: string;
+    name: string;
+    slug: string;
+    featuredAsset: {
+        id: string;
+        preview: string;
+    } | null;
+}
+/** A variant as a picker shows it: what it is, what it costs here and what is in stock. */
+export interface FoundVariant {
+    id: string;
+    name: string;
+    sku: string;
+    /** A disabled variant is listed too; the engine refuses to add it to an order. */
+    enabled: boolean;
+    /**
+     * The variant's price in the store, in the currency asked for, or null when the store has no
+     * price for it there. Never 0 for a missing price.
+     */
+    storePrice: VariantStorePrice | null;
+    trackInventory: InventoryFlag;
+    /** The variant's own threshold; the platform's applies instead when the flag below is true. */
+    outOfStockThreshold: number;
+    useGlobalOutOfStockThreshold: boolean;
+    /**
+     * Units on hand and reserved across the store's locations, as the engine's stock rule reads
+     * them. What an order can still take is `stockOnHand − stockAllocated − threshold`.
+     */
+    stockOnHand: number;
+    stockAllocated: number;
+    /** The same per location; the store's own locations only. */
+    stockLevels: FoundVariantStockLevel[];
+    product: FoundVariantProduct;
+}
+/** One product of a search's answer. */
+export interface FoundVariantsProduct {
+    id: string;
+    /** How many of the product's variants `items` holds. */
+    shown: number;
+    /** How many of its variants match: all of them for `term`, the prefix matches for `skuPrefix`. */
+    total: number;
+}
+export interface FoundVariants {
+    /**
+     * `ids`: in the order asked. A search: best product first, each product's variants together,
+     * in a stable order (by id), which is not the order a merchant arranged them in.
+     */
+    items: FoundVariant[];
+    /**
+     * A search: one entry per product in `items`, in their order. `total` above `shown` means the
+     * product has more matching variants than the answer holds. Empty for `ids`.
+     */
+    products: FoundVariantsProduct[];
+}
+/**
+ * What a picker reads of a variant. `storePrice`, never core's `price` / `priceWithTax`: those
+ * throw for a variant the store has no price for, and one such variant would empty the answer.
+ */
+export declare const FOUND_VARIANT_FIELDS = "\n  id\n  name\n  sku\n  enabled\n  storePrice {\n    price\n    priceWithTax\n    currencyCode\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockOnHand\n  stockAllocated\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n    stockLocation {\n      id\n      name\n    }\n  }\n";
+/** A found variant with its product: the selection of every list that answers variants flat. */
+export declare const FOUND_VARIANT_WITH_PRODUCT_FIELDS = "\n  \n  id\n  name\n  sku\n  enabled\n  storePrice {\n    price\n    priceWithTax\n    currencyCode\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockOnHand\n  stockAllocated\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n    stockLocation {\n      id\n      name\n    }\n  }\n\n  product {\n    \n  id\n  name\n  slug\n  featuredAsset {\n    id\n    preview\n  }\n\n  }\n";
+export declare const FIND_VARIANTS_BY_IDS_QUERY = "\n  query CatalogFindVariantsByIds($options: ProductVariantListOptions) {\n    productVariants(options: $options) {\n      items {\n        \n  \n  id\n  name\n  sku\n  enabled\n  storePrice {\n    price\n    priceWithTax\n    currencyCode\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockOnHand\n  stockAllocated\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n    stockLocation {\n      id\n      name\n    }\n  }\n\n  product {\n    \n  id\n  name\n  slug\n  featuredAsset {\n    id\n    preview\n  }\n\n  }\n\n      }\n      totalItems\n    }\n  }\n";
+/**
+ * The variants of some products, bounded PER PRODUCT (`variantList`, never `variants`, which the
+ * engine answers whole and then cuts at 1,000 without saying so).
+ */
+export declare const FIND_VARIANTS_OF_PRODUCTS_QUERY = "\n  query CatalogFindVariantsOfProducts(\n    $options: ProductListOptions\n    $variantOptions: ProductVariantListOptions\n  ) {\n    products(options: $options) {\n      items {\n        \n  id\n  name\n  slug\n  featuredAsset {\n    id\n    preview\n  }\n\n        variantList(options: $variantOptions) {\n          items {\n            \n  id\n  name\n  sku\n  enabled\n  storePrice {\n    price\n    priceWithTax\n    currencyCode\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockOnHand\n  stockAllocated\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n    stockLocation {\n      id\n      name\n    }\n  }\n\n          }\n          totalItems\n        }\n      }\n      totalItems\n    }\n  }\n";
+interface WireFoundVariant extends Omit<FoundVariant, 'stockLevels' | 'product'> {
+    stockLevels: Array<{
+        stockLocationId: string;
+        stockOnHand: number;
+        stockAllocated: number;
+        stockLocation: {
+            id: string;
+            name: string;
+        } | null;
+    }>;
+}
+/** A found variant as a flat list answers it, its product on the row. */
+export type WireFoundVariantWithProduct = WireFoundVariant & {
+    product: FoundVariantProduct;
+};
+export declare function toFoundVariant(wire: WireFoundVariantWithProduct): FoundVariant;
+/** `catalog.variants.find`; its contract is on `VariantsModule.find`. */
+export declare function findVariants(transport: Transport, input: FindVariantsInput, options?: Call): Promise<FoundVariants>;
+export {};