@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/catalog/types.js

@@ -0,0 +1,141 @@
+import { ConflictError, errorFromErrorResult, isErrorResult, pageFromVendureList, readOffsetCursor, UpstreamError, ValidationError, } from '@sixtyninecommerce/core';
+/** `catalogueOwnership` on the top-level row of each catalogue read (never on nested refs). */
+export const CATALOGUE_OWNERSHIP_FIELDS = /* GraphQL */ `
+  catalogueOwnership {
+    state
+    organizationName
+    editableHere
+  }
+`;
+export const ASSET_REF_FIELDS = /* GraphQL */ `
+  id
+  name
+  preview
+  source
+`;
+export const FACET_VALUE_REF_FIELDS = /* GraphQL */ `
+  id
+  code
+  name
+  facet {
+    id
+    code
+    name
+  }
+`;
+const INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})$/;
+/**
+ * Refuse a datetime with no offset, or one that is not a date at all (spec
+ * §9.3). Returns the value unchanged — the engine stores the instant, and
+ * re-serialising it here would only risk changing its precision.
+ */
+export function assertInstant(field, value) {
+    if (value === null || value === undefined)
+        return;
+    if (typeof value === 'string' && INSTANT.test(value) && !Number.isNaN(Date.parse(value)))
+        return;
+    throw new ValidationError({
+        code: 'INVALID_DATETIME',
+        message: `${field} must be an ISO-8601 instant with an explicit offset, such as "2026-10-01T09:00:00+02:00" or "2026-10-01T07:00:00Z"; got ${JSON.stringify(value)}.`,
+        status: 400,
+        service: 'vendure',
+        details: [{ field, code: 'INVALID_DATETIME', message: 'An offset (Z or ±HH:mm) is required.' }],
+    });
+}
+/**
+ * Split an availability input into the custom fields the Admin API takes. Only
+ * PRESENT keys are copied — an omitted field must reach the server as omitted,
+ * never as null, or a partial update would clear it.
+ */
+export function availabilityCustomFields(input) {
+    assertInstant('availableFrom', input.availableFrom);
+    const fields = {};
+    if (input.availabilityState !== undefined)
+        fields.availabilityState = input.availabilityState;
+    if (input.availableFrom !== undefined)
+        fields.availableFrom = input.availableFrom;
+    if (input.preorderLimit !== undefined)
+        fields.preorderLimit = input.preorderLimit;
+    return fields;
+}
+export const DELETION_FIELDS = /* GraphQL */ `
+  result
+  message
+`;
+/**
+ * `NOT_DELETED` arrives at HTTP 200 with no error, so a caller awaiting a void
+ * promise would read a refusal as success. It becomes a `ConflictError`
+ * carrying the server's own sentence ("The FacetValue … is assigned to 3
+ * Products").
+ */
+export function assertDeleted(code, responses) {
+    const refused = responses.filter((response) => response.result !== 'DELETED');
+    if (refused.length === 0)
+        return;
+    throw new ConflictError({
+        code,
+        message: refused.map((response) => response.message ?? 'The server gave no reason.').join('; '),
+        status: 409,
+        service: 'vendure',
+    });
+}
+/** Throw a Vendure ErrorResult (`MimeTypeError`, `ProductOptionInUseError`) as itself. */
+export function unwrapResult(value) {
+    if (isErrorResult(value))
+        throw errorFromErrorResult(value);
+    return value;
+}
+export const DEFAULT_PAGE_SIZE = 25;
+/** Vendure's `adminListQueryLimit` default; a larger `take` is refused by the engine. */
+export const MAX_PAGE_SIZE = 1000;
+/**
+ * Wrap one of Vendure's `skip/take` lists in a `Page<T>`. The offset hides
+ * inside the cursor (spec §9.3), and every following page re-sends the same
+ * filter, sort and per-call options — a page that forgot its tenant would walk
+ * another store's catalogue.
+ */
+export async function vendureListPage(transport, document, field, variables, options, map = (wire) => wire) {
+    const take = options?.limit ?? DEFAULT_PAGE_SIZE;
+    if (!Number.isInteger(take) || take < 1 || take > MAX_PAGE_SIZE) {
+        throw new ValidationError({
+            code: 'INVALID_PAGE_SIZE',
+            message: `limit must be a whole number from 1 to ${String(MAX_PAGE_SIZE)}; got ${String(take)}.`,
+            status: 400,
+            service: 'vendure',
+        });
+    }
+    const fetchPage = async (skip) => {
+        const data = await transport.graphql({ api: 'admin', query: document, variables: variables(skip, take) }, options);
+        const list = data[field];
+        if (!list) {
+            throw new UpstreamError({
+                code: 'UNEXPECTED_RESPONSE',
+                message: `The engine answered without "${field}".`,
+                status: 502,
+                service: 'vendure',
+            });
+        }
+        return pageFromVendureList({ items: list.items.map(map), totalItems: list.totalItems }, skip, take, (cursor) => fetchPage(readOffsetCursor(cursor)));
+    };
+    return fetchPage(options?.after === undefined ? 0 : readOffsetCursor(options.after));
+}
+/**
+ * Run one Admin API document and answer its single root field — the shape of
+ * almost every catalog call. The field is read by NAME from the response, so a
+ * document and its field name must be kept in step: an ABSENT field is refused
+ * rather than answered as `undefined` (a null one is a real answer), and
+ * `catalog-call-sites.spec.ts` drives every call site with a responder keyed
+ * on the document's own root field.
+ */
+export async function fieldOf(transport, document, field, variables, options) {
+    const data = await transport.graphql({ api: 'admin', query: document, variables }, options);
+    if (data === null || typeof data !== 'object' || !Object.hasOwn(data, field)) {
+        throw new UpstreamError({
+            code: 'UNEXPECTED_RESPONSE',
+            message: `The engine answered without "${field}".`,
+            status: 502,
+            service: 'vendure',
+        });
+    }
+    return data[field];
+}

package/dist/catalog/variants.d.ts

@@ -0,0 +1,324 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+import { type AssetRef, type Availability, type AvailabilityInput, type FacetValueRef, type LanguageCode, type PriceBasis, type TranslationInput, type VariantAvailabilityState } from './types.js';
+export interface StockLevel {
+    stockLocationId: string;
+    stockOnHand: number;
+    stockAllocated: number;
+}
+export interface StockLevelInput {
+    stockLocationId: string;
+    /** Absolute, not a delta. Refused below zero by the engine ("stockOnHand cannot be a negative value"). */
+    stockOnHand: number;
+}
+export type InventoryFlag = 'TRUE' | 'FALSE' | 'INHERIT';
+/**
+ * How a variant takes parcel space (ADR 2026-09-17 parcel-count rule):
+ * `shared` packs with the rest of the order up to the items per parcel,
+ * `separate` never shares a parcel with other items (one unit per parcel unless
+ * `parcelCapacity` is set), `none` never adds one.
+ */
+export type ParcelPacking = 'shared' | 'separate' | 'none';
+/**
+ * A variant's backorder rule: `inherit` follows the store's, `deny` sells nothing below zero,
+ * `incoming` sells up to the stock on its way, `limited` up to `backorderLimit` below zero, and
+ * `unlimited` without a bound.
+ */
+export type VariantBackorderPolicy = 'inherit' | 'deny' | 'incoming' | 'limited' | 'unlimited';
+/** One currency's price of a variant: integer minor units, on the write's `priceBasis`. */
+export interface VariantPriceInput {
+    currencyCode: string;
+    price: number;
+}
+/**
+ * A product variant — the thing that has a SKU, a price and stock.
+ *
+ * Money is integer minor units of `currencyCode`. On READ, `price` is ALWAYS
+ * net and `priceWithTax` ALWAYS gross, whatever the store's basis — core
+ * derives whichever side it does not store, at the rate of the store's default
+ * tax zone. On WRITE, `price` is in the STORE's basis (`priceBasis`). So a
+ * read-modify-write on a gross store (`pricesIncludeTax: true`) must start
+ * from `priceWithTax`: writing back the `price` it read would drop the shelf
+ * price by the whole VAT amount.
+ */
+export interface ProductVariant extends Availability<VariantAvailabilityState> {
+    id: string;
+    productId: string;
+    createdAt: string;
+    updatedAt: string;
+    languageCode: LanguageCode;
+    name: string;
+    sku: string;
+    enabled: boolean;
+    /** Net, always — never the figure to write back on a gross store. */
+    price: number;
+    /** Gross, always, at the store's default tax zone. */
+    priceWithTax: number;
+    currencyCode: string;
+    taxCategory: {
+        id: string;
+        name: string;
+    };
+    /**
+     * The store's tax class this variant belongs to (spec §8.6), or null. When
+     * set, `taxCategory` is the category that class meant for the store's own
+     * country at the moment the variant was last written with it — editing the
+     * class's mappings later does not re-price it.
+     *
+     * A write that sets `taxCategoryId` WITHOUT naming the key (the dashboard's
+     * variant form does this) to a category the class does not mean DETACHES the
+     * class: the key is cleared in the same write, and this reads null.
+     */
+    taxClassKey: string | null;
+    trackInventory: InventoryFlag;
+    outOfStockThreshold: number;
+    useGlobalOutOfStockThreshold: boolean;
+    /**
+     * Units of this variant that fill one parcel. Null uses the store's items per parcel, or 1
+     * when `parcelPacking` is `separate`.
+     */
+    parcelCapacity: number | null;
+    /** Never null on read: an unset packing is `shared`, the engine's default. */
+    parcelPacking: ParcelPacking;
+    stockLevels: StockLevel[];
+    options: Array<{
+        id: string;
+        code: string;
+        name: string;
+        groupId: string;
+    }>;
+    featuredAsset: AssetRef | null;
+    assets: AssetRef[];
+    facetValues: FacetValueRef[];
+    translations: Array<{
+        id: string;
+        languageCode: LanguageCode;
+        name: string;
+    }>;
+}
+export interface VariantTranslationInput extends TranslationInput {
+    name?: string;
+}
+interface VariantFields extends AvailabilityInput<VariantAvailabilityState> {
+    enabled?: boolean;
+    translations?: VariantTranslationInput[];
+    /** One option from EACH of the product's option groups, and a combination no other variant has. */
+    optionIds?: string[];
+    /**
+     * Integer minor units in the store's default currency, stated on
+     * `priceBasis`. The two travel together: a price without its basis is
+     * refused (`PRICE_BASIS_REQUIRED`), and a basis other than the store's is
+     * refused (`PRICE_BASIS_MISMATCH`) — see {@link PriceBasis}.
+     */
+    price?: number;
+    priceBasis?: PriceBasis;
+    /**
+     * Set the category directly. Mutually exclusive with a `taxClassKey` naming
+     * a different category (`INVALID_TAX_CATEGORY_FOR_CLASS`).
+     */
+    taxCategoryId?: string;
+    /**
+     * The store's tax class (spec §8.6). The engine resolves it for the store's
+     * own business country and writes the resulting `taxCategoryId` in the same
+     * write. Refusals, in the engine's words: `TAX_CLASS_NOT_FOUND`
+     * (`NotFoundError`) — "This store has no tax class with the key "…"." — and
+     * `TAX_CLASS_UNMAPPED` (`ValidationError`) — "The tax class "…" has no tax
+     * category for NL and no "*" fallback. Map it before using it here."
+     *
+     * Null clears the key and leaves the category as it is.
+     */
+    taxClassKey?: string | null;
+    /**
+     * A whole number from 1 to 10,000, or null for the default (the store's items per
+     * parcel, or 1 when `parcelPacking` is `separate`). Anything else is refused before sending (`INVALID_PARCEL_CAPACITY`).
+     */
+    parcelCapacity?: number | null;
+    /**
+     * `shared` and null both store null — the one way "shared" is stored, so a
+     * read never tells them apart. Another value is refused before sending
+     * (`INVALID_PARCEL_PACKING`).
+     */
+    parcelPacking?: ParcelPacking | null;
+    /** The fewest units one order line may carry; null for no minimum. */
+    minOrderQuantity?: number | null;
+    /** The units a line's quantity moves in (6: 6, 12, 18 …); null for one. */
+    salesUnit?: number | null;
+    /** What one unit costs the store, integer minor units of its default currency; null clears it. */
+    cost?: number | null;
+    packageWeightGrams?: number | null;
+    packageLengthCm?: number | null;
+    packageWidthCm?: number | null;
+    packageHeightCm?: number | null;
+    /** Null: `inherit`. */
+    backorderPolicy?: VariantBackorderPolicy | null;
+    /** The units a `limited` variant may sell below zero. */
+    backorderLimit?: number | null;
+    /**
+     * GS1 barcode: 8, 12, 13 or 14 digits when new or changed (`FEED_IDENTIFIER_INVALID`
+     * otherwise); null or blank clears it. A stored value sent back unchanged is never judged.
+     */
+    gtin?: string | null;
+    /** Manufacturer part number; null or blank clears it. */
+    mpn?: string | null;
+    stockLevels?: StockLevelInput[];
+    trackInventory?: InventoryFlag;
+    outOfStockThreshold?: number;
+    useGlobalOutOfStockThreshold?: boolean;
+    featuredAssetId?: string | null;
+    assetIds?: string[];
+    facetValueIds?: string[];
+}
+/**
+ * Where a store's price in one currency comes from (multi-region decision 59):
+ * - `OWN` — a price the store stored itself, or its own change of its organization's price.
+ * - `INHERITED` — the organization's stored price, copied to the store and unchanged since; it
+ *   follows the organization's later changes.
+ * - `CONVERTED` — nothing stored: the storefront converts the store's EUR price at the store's
+ *   exchange rate.
+ *
+ * A string on the wire: a newer engine may answer a source this SDK does not name yet.
+ */
+export type VariantPriceSourceKind = 'OWN' | 'INHERITED' | 'CONVERTED';
+/** One currency the active store sells, and where the variant's price in it comes from. */
+export interface VariantPriceSource {
+    currencyCode: string;
+    /**
+     * What the store charges in this currency, in minor units, on the STORE's basis: gross on a
+     * store with `pricesIncludeTax`, net otherwise — the basis a variant write takes, unlike
+     * {@link ProductVariant.price}, which reads net everywhere. Null when nothing prices it: no
+     * stored price and no EUR price or exchange rate to convert from, or a currency the store
+     * marked not for sale.
+     */
+    price: number | null;
+    source: VariantPriceSourceKind | (string & {});
+    /**
+     * The organization's stored price in this currency, on the same basis (an organization and its
+     * stores enter prices the same way). Null when no organization shares the variant with the
+     * store, or the organization stores no price in this currency.
+     */
+    organizationPrice: number | null;
+    /** The organization that shares the variant with the store; null for the store's own variant. */
+    organizationName: string | null;
+}
+/** The engine's bound on one `revertPrice` call (`MAX_REVERT_VARIANTS`). */
+export declare const MAX_REVERT_PRICE_VARIANTS = 500;
+export interface CreateProductVariantInput extends VariantFields {
+    productId: string;
+    sku: string;
+    translations: VariantTranslationInput[];
+}
+/** A PATCH: omitted fields are left alone. */
+export interface UpdateProductVariantInput extends VariantFields {
+    id: string;
+    sku?: string;
+    /**
+     * The price in each named currency, integer minor units on `priceBasis` (required beside it,
+     * as for `price`). A currency left out keeps its price. Update only: the engine's create takes
+     * `price` alone and would drop this list without a word.
+     */
+    prices?: VariantPriceInput[];
+}
+/**
+ * Variant writes. Reading needs `ReadCatalog`, creating `CreateCatalog`,
+ * updating (stock included) `UpdateCatalog`, deleting `DeleteCatalog`.
+ *
+ * Refusals, in the engine's words: `optionIds` that do not name one option per
+ * group — "ProductVariant optionIds must include one optionId from each of the
+ * groups: …" — or repeat another variant's combination — "A ProductVariant with
+ * the selected options already exists: …" — and a negative stock level —
+ * "stockOnHand cannot be a negative value" — all arrive as `ValidationError`
+ * (`USER_INPUT_ERROR`). An id this store does not have is a `NotFoundError`
+ * (`ENTITY_NOT_FOUND`). A product may have ONE variant without options; a
+ * second is refused the same way.
+ *
+ * While an app or API token of the store owns a field group (`admin.tenant.fieldGroupOwners()`),
+ * an update or delete of a variant that would change its Price, Stock or
+ * Product details by anyone else is refused `FIELD_GROUP_LOCKED`
+ * (`BusinessRuleError`, 422) and nothing is written; `error.details` names each refused field
+ * (`field` is a JSON pointer into the call, e.g. `/input/0/price`). A value equal to the stored
+ * one passes and is left out of the write. See the README, "Field groups: what an owned group
+ * refuses".
+ */
+export interface VariantsModule {
+    list(productId: string, options?: ListOptions): Promise<Page<ProductVariant>>;
+    get(id: string, options?: Call): Promise<ProductVariant | null>;
+    /** All or nothing: the engine creates the batch in one transaction. */
+    create(inputs: CreateProductVariantInput[], options?: Call): Promise<ProductVariant[]>;
+    update(inputs: UpdateProductVariantInput[], options?: Call): Promise<ProductVariant[]>;
+    delete(ids: string[], options?: Call): Promise<void>;
+    /**
+     * Set stock on hand per stock location — absolute values, one update. A
+     * location not named keeps its level. Stock MOVEMENTS with a reason are the
+     * `stock` module's (spec §9.2), not this.
+     */
+    setStockLevels(variantId: string, levels: StockLevelInput[], options?: Call): Promise<ProductVariant>;
+    /**
+     * Where each of the variant's prices in the ACTIVE store comes from: one entry per currency the
+     * store sells, in the store's currency order. A store outside any organization, and a variant
+     * of the store's own, read `OWN` or `CONVERTED` only. Needs `ReadCatalog`. An id this store
+     * does not have is a `NotFoundError` (`VARIANT_NOT_FOUND`).
+     */
+    priceSources(variantId: string, options?: Call): Promise<VariantPriceSource[]>;
+    /**
+     * The active store's prices of variants its organization shares with it become the
+     * organization's stored prices again (`INHERITED`), and follow its later changes. Without
+     * `currencyCodes`: every currency the store sells and the organization prices, bar one the store
+     * marked not for sale and stores no price in (a stored price sells the currency whatever its
+     * mark, so it is reverted); an empty list reverts nothing. Needs `UpdateCatalog` (or
+     * `UpdateProduct`), what a variant price write needs. All or nothing, and audited per variant.
+     * Answers the variants as the store sees them. An Admin API mutation: an idempotency key
+     * deduplicates nothing, and a repeat answers the same prices.
+     *
+     * Refusals (nothing is written), GraphQL errors mapped by `core`:
+     * - `ORGANIZATION_PRICE_LOCAL_VARIANT` → `BusinessRuleError` (422): a variant of the store's
+     *   own, or the organization does not share its catalog.
+     * - `ORGANIZATION_PRICE_MISSING` → `BusinessRuleError` (422): the organization stores no price
+     *   in a currency named (or in any the store sells).
+     * - `ORGANIZATION_PRICE_NOT_REVERTIBLE` → `BusinessRuleError` (422): a named currency the store
+     *   does not sell, or marked not for sale for the variant with no price stored in it.
+     * - `ORGANIZATION_WORKSPACE_NOT_A_STORE` → `BusinessRuleError` (422): called in an
+     *   organization's workspace, whose prices are the organization's own.
+     * - `ORGANIZATION_PRICE_REVERT_INVALID` → `ValidationError` (400): more than
+     *   {@link MAX_REVERT_PRICE_VARIANTS} distinct ids; refused before sending too.
+     * - `ENTITY_NOT_FOUND` → `NotFoundError` (404): an id this store does not have.
+     */
+    revertPrice(variantIds: string[], options?: Call & {
+        currencyCodes?: readonly string[];
+    }): Promise<ProductVariant[]>;
+}
+export declare const VARIANT_FIELDS = "\n  id\n  productId\n  createdAt\n  updatedAt\n  languageCode\n  name\n  sku\n  enabled\n  price\n  priceWithTax\n  currencyCode\n  taxCategory {\n    id\n    name\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n  }\n  options {\n    id\n    code\n    name\n    groupId\n  }\n  featuredAsset { \n  id\n  name\n  preview\n  source\n }\n  assets { \n  id\n  name\n  preview\n  source\n }\n  facetValues { \n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n  }\n  customFields {\n    taxClassKey\n    availabilityState\n    availableFrom\n    preorderLimit\n    parcelCapacity\n    parcelPacking\n  }\n";
+export declare const VARIANTS_QUERY = "\n  query CatalogVariants($productId: ID!, $options: ProductVariantListOptions) {\n    productVariants(productId: $productId, options: $options) {\n      items { \n  id\n  productId\n  createdAt\n  updatedAt\n  languageCode\n  name\n  sku\n  enabled\n  price\n  priceWithTax\n  currencyCode\n  taxCategory {\n    id\n    name\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n  }\n  options {\n    id\n    code\n    name\n    groupId\n  }\n  featuredAsset { \n  id\n  name\n  preview\n  source\n }\n  assets { \n  id\n  name\n  preview\n  source\n }\n  facetValues { \n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n  }\n  customFields {\n    taxClassKey\n    availabilityState\n    availableFrom\n    preorderLimit\n    parcelCapacity\n    parcelPacking\n  }\n }\n      totalItems\n    }\n  }\n";
+export declare const VARIANT_QUERY = "\n  query CatalogVariant($id: ID!) {\n    productVariant(id: $id) { \n  id\n  productId\n  createdAt\n  updatedAt\n  languageCode\n  name\n  sku\n  enabled\n  price\n  priceWithTax\n  currencyCode\n  taxCategory {\n    id\n    name\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n  }\n  options {\n    id\n    code\n    name\n    groupId\n  }\n  featuredAsset { \n  id\n  name\n  preview\n  source\n }\n  assets { \n  id\n  name\n  preview\n  source\n }\n  facetValues { \n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n  }\n  customFields {\n    taxClassKey\n    availabilityState\n    availableFrom\n    preorderLimit\n    parcelCapacity\n    parcelPacking\n  }\n }\n  }\n";
+export declare const CREATE_VARIANTS_MUTATION = "\n  mutation CatalogCreateVariants($input: [CreateProductVariantInput!]!) {\n    createProductVariants(input: $input) { \n  id\n  productId\n  createdAt\n  updatedAt\n  languageCode\n  name\n  sku\n  enabled\n  price\n  priceWithTax\n  currencyCode\n  taxCategory {\n    id\n    name\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n  }\n  options {\n    id\n    code\n    name\n    groupId\n  }\n  featuredAsset { \n  id\n  name\n  preview\n  source\n }\n  assets { \n  id\n  name\n  preview\n  source\n }\n  facetValues { \n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n  }\n  customFields {\n    taxClassKey\n    availabilityState\n    availableFrom\n    preorderLimit\n    parcelCapacity\n    parcelPacking\n  }\n }\n  }\n";
+export declare const UPDATE_VARIANTS_MUTATION = "\n  mutation CatalogUpdateVariants($input: [UpdateProductVariantInput!]!) {\n    updateProductVariants(input: $input) { \n  id\n  productId\n  createdAt\n  updatedAt\n  languageCode\n  name\n  sku\n  enabled\n  price\n  priceWithTax\n  currencyCode\n  taxCategory {\n    id\n    name\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n  }\n  options {\n    id\n    code\n    name\n    groupId\n  }\n  featuredAsset { \n  id\n  name\n  preview\n  source\n }\n  assets { \n  id\n  name\n  preview\n  source\n }\n  facetValues { \n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n  }\n  customFields {\n    taxClassKey\n    availabilityState\n    availableFrom\n    preorderLimit\n    parcelCapacity\n    parcelPacking\n  }\n }\n  }\n";
+export declare const DELETE_VARIANTS_MUTATION = "\n  mutation CatalogDeleteVariants($ids: [ID!]!) {\n    deleteProductVariants(ids: $ids) { \n  result\n  message\n }\n  }\n";
+/**
+ * A document of its own, never a field of `VARIANT_FIELDS`: every other variant read keeps
+ * working against an engine older than the field, and pays nothing for it.
+ */
+export declare const VARIANT_PRICE_SOURCES_QUERY = "\n  query CatalogVariantPriceSources($id: ID!) {\n    productVariant(id: $id) {\n      id\n      priceSources {\n        currencyCode\n        price\n        source\n        organizationPrice\n        organizationName\n      }\n    }\n  }\n";
+export declare const REVERT_TO_ORGANIZATION_PRICE_MUTATION = "\n  mutation CatalogRevertToOrganizationPrice($variantIds: [ID!]!, $currencyCodes: [CurrencyCode!]) {\n    revertToOrganizationPrice(variantIds: $variantIds, currencyCodes: $currencyCodes) { \n  id\n  productId\n  createdAt\n  updatedAt\n  languageCode\n  name\n  sku\n  enabled\n  price\n  priceWithTax\n  currencyCode\n  taxCategory {\n    id\n    name\n  }\n  trackInventory\n  outOfStockThreshold\n  useGlobalOutOfStockThreshold\n  stockLevels {\n    stockLocationId\n    stockOnHand\n    stockAllocated\n  }\n  options {\n    id\n    code\n    name\n    groupId\n  }\n  featuredAsset { \n  id\n  name\n  preview\n  source\n }\n  assets { \n  id\n  name\n  preview\n  source\n }\n  facetValues { \n  id\n  code\n  name\n  facet {\n    id\n    code\n    name\n  }\n }\n  translations {\n    id\n    languageCode\n    name\n  }\n  customFields {\n    taxClassKey\n    availabilityState\n    availableFrom\n    preorderLimit\n    parcelCapacity\n    parcelPacking\n  }\n }\n  }\n";
+/** The price basis the store stores, read on the SAME tenant as the write. */
+export declare const PRICE_BASIS_QUERY = "\n  query CatalogPriceBasis {\n    activeChannel {\n      pricesIncludeTax\n    }\n  }\n";
+interface WireVariant extends Omit<ProductVariant, keyof Availability<string> | 'taxClassKey' | 'parcelCapacity' | 'parcelPacking'> {
+    customFields: (Partial<Availability<VariantAvailabilityState>> & {
+        taxClassKey?: string | null;
+        parcelCapacity?: number | null;
+        parcelPacking?: string | null;
+    }) | null;
+}
+export declare function toVariant(wire: WireVariant): ProductVariant;
+/** A write's prices and the basis it states them on. */
+export interface PricedInput {
+    price?: number;
+    prices?: readonly VariantPriceInput[];
+    priceBasis?: PriceBasis;
+}
+/**
+ * Every priced input (`price`, or any `prices` entry) must be whole minor units and state its
+ * basis, and the basis must be the store's. Read per call, with the call's own options, so a
+ * per-call tenant is checked against ITS store rather than the client's default one.
+ */
+export declare function assertPricesStateBasis(transport: Transport, inputs: readonly PricedInput[], options?: Call): Promise<void>;
+export declare function createVariantsModule(transport: Transport): VariantsModule;
+export {};