@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/catalog/properties.d.ts

@@ -0,0 +1,234 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+import { type LanguageCode } from './types.js';
+/**
+ * The field types a property may have, as the properties plugin stores them.
+ * `content_item` and `product` hold a list of ids; the rest hold one value.
+ */
+export type PropertyFieldType = string;
+export interface PropertyConfig {
+    /** For `enum` / `multi_enum`. */
+    options?: Array<{
+        value: string;
+        label: string;
+    }> | null;
+    min?: number | null;
+    max?: number | null;
+    maxLength?: number | null;
+    allowedCollectionIds?: string[] | null;
+    filterableFieldSlugs?: string[] | null;
+    /** Stored verbatim; its keys are the caller's own. */
+    productFilter?: unknown;
+}
+export interface Property {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    /** Unique within the group; the storefront's key for the value. */
+    slug: string;
+    fieldType: PropertyFieldType;
+    /** A filterable property mirrors its values onto a facet (`facetId`). */
+    isFilterable: boolean;
+    isRequired: boolean;
+    position: number;
+    config: PropertyConfig | null;
+    facetId: string | null;
+    translations: Array<{
+        id: string;
+        languageCode: LanguageCode;
+        name: string;
+        helpText: string | null;
+    }>;
+}
+export interface PropertyGroup {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    position: number;
+    translations: Array<{
+        id: string;
+        languageCode: LanguageCode;
+        name: string;
+    }>;
+    properties: Property[];
+    /**
+     * Whether the group, its properties and their values are written from the active channel. False
+     * for a workspace group a member store reads on a product it holds from its organization
+     * (`values.get`; decision 80): change the group, its properties and its values in the
+     * workspace. A `values.set` changing one of its values is refused whole
+     * (`MANAGED_BY_ORGANIZATION`); one echoing them unchanged is accepted. `groups.list` answers
+     * the store's own groups only, so their `editableHere` is true. Unlike
+     * `CatalogueOwnership.editableHere` it ignores the caller's permissions.
+     */
+    editableHere: boolean;
+}
+/** One stored value. `languageCode` null: a language-neutral value (every non-text type). */
+export interface ProductPropertyValue {
+    id: string;
+    propertyId: string;
+    languageCode: LanguageCode | null;
+    /** Stored verbatim — never case-converted by this SDK. */
+    value: unknown;
+}
+export interface ProductPropertyGroupValues {
+    group: PropertyGroup;
+    values: ProductPropertyValue[];
+}
+export interface CreatePropertyGroupInput {
+    translations: Array<{
+        languageCode: LanguageCode;
+        name: string;
+    }>;
+    position?: number;
+}
+export interface UpdatePropertyGroupInput {
+    id: string;
+    translations?: Array<{
+        languageCode: LanguageCode;
+        name: string;
+    }>;
+    position?: number;
+}
+export interface CreatePropertyInput {
+    groupId: string;
+    fieldType: PropertyFieldType;
+    slug: string;
+    isFilterable?: boolean;
+    isRequired?: boolean;
+    config?: PropertyConfig;
+    position?: number;
+    translations: Array<{
+        languageCode: LanguageCode;
+        name: string;
+        helpText?: string;
+    }>;
+}
+export interface UpdatePropertyInput {
+    id: string;
+    slug?: string;
+    isFilterable?: boolean;
+    isRequired?: boolean;
+    config?: PropertyConfig;
+    position?: number;
+    translations?: Array<{
+        languageCode: LanguageCode;
+        name: string;
+        helpText?: string;
+    }>;
+}
+export interface SetPropertyValueInput {
+    propertyId: string;
+    /**
+     * The value's language, for a translatable (text) type. Ignored — stored
+     * language-neutral — for every other type, whatever is sent.
+     */
+    languageCode?: LanguageCode | null;
+    /** `null` clears it. A single id for a `content_item`/`product` property is stored as a one-item list. */
+    value: unknown;
+    /** The facet value's label, for a filterable `content_item`/`product` property. */
+    displayName?: string;
+    /** Per content item, the fields a field-level facet is built from. */
+    fieldValues?: Record<string, Record<string, unknown>>;
+}
+/** What {@link CatalogModule.syncContentFacets} did. */
+export interface ContentFacetSyncResult {
+    propertyId: string;
+    /**
+     * How many content items (a `content_item` property) or products (a `product` property) the
+     * property's values name. Each was given its current label; 0 when the property names none, and
+     * then nothing was written.
+     */
+    items: number;
+    /**
+     * The named ids the label source did not answer: a content item that no longer exists, an id
+     * that is not one, a product this store does not hold. Their filter values keep the label they
+     * have, and a new one is labelled with the id itself.
+     */
+    unresolved: string[];
+    /**
+     * How many field-level facets were brought in line with the content items' field values (a
+     * `content_item` property whose saved configuration names fields to filter by), else 0.
+     */
+    fieldFacets: number;
+}
+/**
+ * Product properties: typed, grouped attributes a merchant defines once per
+ * store and fills per product (the properties plugin). Reading needs
+ * `ReadCatalog`; creating `CreateCatalog`, updating (values included)
+ * `UpdateCatalog`, deleting `DeleteCatalog`.
+ *
+ * Refusals of the group and property doors, GraphQL errors mapped by `core`:
+ * - `PROPERTY_GROUP_NOT_FOUND` → `NotFoundError` (404): `groups.update`,
+ *   `create` (its `groupId`), `reorder` (its `groupId`) and `groups.reorder`
+ *   (any of its ids, all checked before any group moves) name a group this
+ *   store does not own. An older platform release skips such an id in
+ *   `groups.reorder` and answers the store's groups as they are.
+ * - `PROPERTY_NOT_FOUND` → `NotFoundError` (404): `update` names a property of
+ *   no group this store owns.
+ * - `PROPERTY_FILTERABLE_INVALID` → `ValidationError` (400): `isFilterable` on
+ *   a field type that cannot carry a facet.
+ * - `MANAGED_BY_ORGANIZATION` → `BusinessRuleError` (422): in a store of an
+ *   organization, any of those doors given a group or property of the
+ *   workspace's groups it reads (`editableHere` false), `groups.reorder`
+ *   included: edit it in the workspace.
+ *
+ * A platform release older than these codes sends them uncoded, as a
+ * non-retryable `UpstreamError` (status 500, `GRAPHQL_ERROR`) whose message is
+ * the engine's sentence. A delete of a group or property the store does not
+ * own is a `ConflictError` (`PROPERTY_GROUP_NOT_DELETED` /
+ * `PROPERTY_NOT_DELETED`), or `MANAGED_BY_ORGANIZATION` for the workspace's.
+ *
+ * `values.set` checks every value before it writes any. It answers
+ * `ENTITY_NOT_FOUND` for a product outside this store and for a `propertyId`
+ * this store neither owns nor reads. In a store of an organization it
+ * ignores an unchanged echo of a workspace property's value, but refuses a
+ * change to one with `MANAGED_BY_ORGANIZATION`, and the whole call with it.
+ */
+export interface PropertiesModule {
+    groups: {
+        /** The complete list, as one terminal page — the query takes no paging. */
+        list(options?: Call): Promise<Page<PropertyGroup>>;
+        get(id: string, options?: Call): Promise<PropertyGroup | null>;
+        create(input: CreatePropertyGroupInput, options?: Call): Promise<PropertyGroup>;
+        update(input: UpdatePropertyGroupInput, options?: Call): Promise<PropertyGroup>;
+        /** Deletes the group AND every property in it, with their values. */
+        delete(id: string, options?: Call): Promise<void>;
+        /**
+         * Pass EVERY group id of the store, in the order wanted. Only the store's own groups:
+         * a workspace group (`editableHere` false) or another store's id refuses the whole call.
+         */
+        reorder(ids: string[], options?: Call): Promise<PropertyGroup[]>;
+    };
+    create(input: CreatePropertyInput, options?: Call): Promise<Property>;
+    update(input: UpdatePropertyInput, options?: Call): Promise<Property>;
+    delete(id: string, options?: Call): Promise<void>;
+    /** Pass every property id of the group, in the order wanted. */
+    reorder(groupId: string, propertyIds: string[], options?: Call): Promise<Property[]>;
+    values: {
+        /**
+         * Every group of the store, each with this product's stored values in every language. For a
+         * product the store holds from its organization, the workspace's groups and values come too,
+         * with `group.editableHere` false.
+         */
+        get(productId: string, options?: Call): Promise<ProductPropertyGroupValues[]>;
+        /** Upsert the given values; properties not named keep theirs. */
+        set(productId: string, values: SetPropertyValueInput[], options?: Call): Promise<void>;
+    };
+}
+export declare const PROPERTY_GROUP_FIELDS = "\n  id\n  createdAt\n  updatedAt\n  position\n  translations {\n    id\n    languageCode\n    name\n  }\n  properties { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  editableHere\n";
+export declare const PROPERTY_GROUPS_QUERY = "\n  query CatalogPropertyGroups {\n    propertyGroups { \n  id\n  createdAt\n  updatedAt\n  position\n  translations {\n    id\n    languageCode\n    name\n  }\n  properties { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  editableHere\n }\n  }\n";
+export declare const PROPERTY_GROUP_QUERY = "\n  query CatalogPropertyGroup($id: ID!) {\n    propertyGroup(id: $id) { \n  id\n  createdAt\n  updatedAt\n  position\n  translations {\n    id\n    languageCode\n    name\n  }\n  properties { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  editableHere\n }\n  }\n";
+export declare const CREATE_PROPERTY_GROUP_MUTATION = "\n  mutation CatalogCreatePropertyGroup($input: CreatePropertyGroupInput!) {\n    createPropertyGroup(input: $input) { \n  id\n  createdAt\n  updatedAt\n  position\n  translations {\n    id\n    languageCode\n    name\n  }\n  properties { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  editableHere\n }\n  }\n";
+export declare const UPDATE_PROPERTY_GROUP_MUTATION = "\n  mutation CatalogUpdatePropertyGroup($input: UpdatePropertyGroupInput!) {\n    updatePropertyGroup(input: $input) { \n  id\n  createdAt\n  updatedAt\n  position\n  translations {\n    id\n    languageCode\n    name\n  }\n  properties { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  editableHere\n }\n  }\n";
+export declare const DELETE_PROPERTY_GROUP_MUTATION = "\n  mutation CatalogDeletePropertyGroup($id: ID!) {\n    deletePropertyGroup(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const REORDER_PROPERTY_GROUPS_MUTATION = "\n  mutation CatalogReorderPropertyGroups($ids: [ID!]!) {\n    reorderPropertyGroups(ids: $ids) { \n  id\n  createdAt\n  updatedAt\n  position\n  translations {\n    id\n    languageCode\n    name\n  }\n  properties { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  editableHere\n }\n  }\n";
+export declare const CREATE_PROPERTY_MUTATION = "\n  mutation CatalogCreateProperty($input: CreatePropertyInput!) {\n    createProperty(input: $input) { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  }\n";
+export declare const UPDATE_PROPERTY_MUTATION = "\n  mutation CatalogUpdateProperty($input: UpdatePropertyInput!) {\n    updateProperty(input: $input) { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  }\n";
+export declare const DELETE_PROPERTY_MUTATION = "\n  mutation CatalogDeleteProperty($id: ID!) {\n    deleteProperty(id: $id) { \n  result\n  message\n }\n  }\n";
+export declare const REORDER_PROPERTIES_MUTATION = "\n  mutation CatalogReorderProperties($groupId: ID!, $propertyIds: [ID!]!) {\n    reorderProperties(groupId: $groupId, propertyIds: $propertyIds) { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  }\n";
+export declare const PRODUCT_PROPERTY_VALUES_QUERY = "\n  query CatalogProductPropertyValues($productId: ID!) {\n    productPropertyValues(productId: $productId) {\n      group { \n  id\n  createdAt\n  updatedAt\n  position\n  translations {\n    id\n    languageCode\n    name\n  }\n  properties { \n  id\n  createdAt\n  updatedAt\n  slug\n  fieldType\n  isFilterable\n  isRequired\n  position\n  config {\n    options {\n      value\n      label\n    }\n    min\n    max\n    maxLength\n    allowedCollectionIds\n    filterableFieldSlugs\n    productFilter\n  }\n  facetId\n  translations {\n    id\n    languageCode\n    name\n    helpText\n  }\n }\n  editableHere\n }\n      values {\n        id\n        propertyId\n        languageCode\n        value\n      }\n    }\n  }\n";
+export declare const SET_PRODUCT_PROPERTY_VALUES_MUTATION = "\n  mutation CatalogSetProductPropertyValues($productId: ID!, $values: [SetProductPropertyValueInput!]!) {\n    setProductPropertyValues(productId: $productId, values: $values)\n  }\n";
+export declare const SYNC_PROPERTY_FACETS_MUTATION = "\n  mutation CatalogSyncPropertyFacets($propertyId: ID!) {\n    syncPropertyFacets(propertyId: $propertyId) {\n      propertyId\n      items\n      unresolved\n      fieldFacets\n    }\n  }\n";
+/** `catalog.syncContentFacets`; its contract is on {@link CatalogModule.syncContentFacets}. */
+export declare function syncContentFacets(transport: Transport, propertyId: string, options?: Call): Promise<ContentFacetSyncResult>;
+export declare function createPropertiesModule(transport: Transport): PropertiesModule;

package/dist/catalog/properties.js

@@ -0,0 +1,158 @@
+import { createPage } from '@sixtyninecommerce/core';
+import { assertDeleted, DELETION_FIELDS, fieldOf, } from './types.js';
+const PROPERTY_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  slug
+  fieldType
+  isFilterable
+  isRequired
+  position
+  config {
+    options {
+      value
+      label
+    }
+    min
+    max
+    maxLength
+    allowedCollectionIds
+    filterableFieldSlugs
+    productFilter
+  }
+  facetId
+  translations {
+    id
+    languageCode
+    name
+    helpText
+  }
+`;
+export const PROPERTY_GROUP_FIELDS = /* GraphQL */ `
+  id
+  createdAt
+  updatedAt
+  position
+  translations {
+    id
+    languageCode
+    name
+  }
+  properties { ${PROPERTY_FIELDS} }
+  editableHere
+`;
+export const PROPERTY_GROUPS_QUERY = /* GraphQL */ `
+  query CatalogPropertyGroups {
+    propertyGroups { ${PROPERTY_GROUP_FIELDS} }
+  }
+`;
+export const PROPERTY_GROUP_QUERY = /* GraphQL */ `
+  query CatalogPropertyGroup($id: ID!) {
+    propertyGroup(id: $id) { ${PROPERTY_GROUP_FIELDS} }
+  }
+`;
+export const CREATE_PROPERTY_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogCreatePropertyGroup($input: CreatePropertyGroupInput!) {
+    createPropertyGroup(input: $input) { ${PROPERTY_GROUP_FIELDS} }
+  }
+`;
+export const UPDATE_PROPERTY_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdatePropertyGroup($input: UpdatePropertyGroupInput!) {
+    updatePropertyGroup(input: $input) { ${PROPERTY_GROUP_FIELDS} }
+  }
+`;
+export const DELETE_PROPERTY_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogDeletePropertyGroup($id: ID!) {
+    deletePropertyGroup(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const REORDER_PROPERTY_GROUPS_MUTATION = /* GraphQL */ `
+  mutation CatalogReorderPropertyGroups($ids: [ID!]!) {
+    reorderPropertyGroups(ids: $ids) { ${PROPERTY_GROUP_FIELDS} }
+  }
+`;
+export const CREATE_PROPERTY_MUTATION = /* GraphQL */ `
+  mutation CatalogCreateProperty($input: CreatePropertyInput!) {
+    createProperty(input: $input) { ${PROPERTY_FIELDS} }
+  }
+`;
+export const UPDATE_PROPERTY_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdateProperty($input: UpdatePropertyInput!) {
+    updateProperty(input: $input) { ${PROPERTY_FIELDS} }
+  }
+`;
+export const DELETE_PROPERTY_MUTATION = /* GraphQL */ `
+  mutation CatalogDeleteProperty($id: ID!) {
+    deleteProperty(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const REORDER_PROPERTIES_MUTATION = /* GraphQL */ `
+  mutation CatalogReorderProperties($groupId: ID!, $propertyIds: [ID!]!) {
+    reorderProperties(groupId: $groupId, propertyIds: $propertyIds) { ${PROPERTY_FIELDS} }
+  }
+`;
+export const PRODUCT_PROPERTY_VALUES_QUERY = /* GraphQL */ `
+  query CatalogProductPropertyValues($productId: ID!) {
+    productPropertyValues(productId: $productId) {
+      group { ${PROPERTY_GROUP_FIELDS} }
+      values {
+        id
+        propertyId
+        languageCode
+        value
+      }
+    }
+  }
+`;
+export const SET_PRODUCT_PROPERTY_VALUES_MUTATION = /* GraphQL */ `
+  mutation CatalogSetProductPropertyValues($productId: ID!, $values: [SetProductPropertyValueInput!]!) {
+    setProductPropertyValues(productId: $productId, values: $values)
+  }
+`;
+export const SYNC_PROPERTY_FACETS_MUTATION = /* GraphQL */ `
+  mutation CatalogSyncPropertyFacets($propertyId: ID!) {
+    syncPropertyFacets(propertyId: $propertyId) {
+      propertyId
+      items
+      unresolved
+      fieldFacets
+    }
+  }
+`;
+/** `catalog.syncContentFacets`; its contract is on {@link CatalogModule.syncContentFacets}. */
+export function syncContentFacets(transport, propertyId, options) {
+    return fieldOf(transport, SYNC_PROPERTY_FACETS_MUTATION, 'syncPropertyFacets', { propertyId }, options);
+}
+export function createPropertiesModule(transport) {
+    const call = (document, field, variables, options) => fieldOf(transport, document, field, variables, options);
+    const deleted = async (document, field, code, id, options) => {
+        assertDeleted(code, [await call(document, field, { id }, options)]);
+    };
+    return {
+        groups: {
+            async list(options) {
+                const items = await call(PROPERTY_GROUPS_QUERY, 'propertyGroups', {}, options);
+                return createPage(items, { nextCursor: null, hasNext: false, total: items.length }, () => {
+                    // Unreachable while `hasNext` is false — `Page.next()` short-circuits.
+                    throw new Error('propertyGroups returns a complete list; there is no next page');
+                });
+            },
+            get: (id, options) => call(PROPERTY_GROUP_QUERY, 'propertyGroup', { id }, options),
+            create: (input, options) => call(CREATE_PROPERTY_GROUP_MUTATION, 'createPropertyGroup', { input }, options),
+            update: (input, options) => call(UPDATE_PROPERTY_GROUP_MUTATION, 'updatePropertyGroup', { input }, options),
+            delete: (id, options) => deleted(DELETE_PROPERTY_GROUP_MUTATION, 'deletePropertyGroup', 'PROPERTY_GROUP_NOT_DELETED', id, options),
+            reorder: (ids, options) => call(REORDER_PROPERTY_GROUPS_MUTATION, 'reorderPropertyGroups', { ids }, options),
+        },
+        create: (input, options) => call(CREATE_PROPERTY_MUTATION, 'createProperty', { input }, options),
+        update: (input, options) => call(UPDATE_PROPERTY_MUTATION, 'updateProperty', { input }, options),
+        delete: (id, options) => deleted(DELETE_PROPERTY_MUTATION, 'deleteProperty', 'PROPERTY_NOT_DELETED', id, options),
+        reorder: (groupId, propertyIds, options) => call(REORDER_PROPERTIES_MUTATION, 'reorderProperties', { groupId, propertyIds }, options),
+        values: {
+            get: (productId, options) => call(PRODUCT_PROPERTY_VALUES_QUERY, 'productPropertyValues', { productId }, options),
+            async set(productId, values, options) {
+                await call(SET_PRODUCT_PROPERTY_VALUES_MUTATION, 'setProductPropertyValues', { productId, values }, options);
+            },
+        },
+    };
+}

package/dist/catalog/types.d.ts

@@ -0,0 +1,174 @@
+import { type Page, type Transport } from '@sixtyninecommerce/core';
+import type { Call, ListOptions } from '../types.js';
+/** A language code as Vendure spells it: `en`, `nl`, `pt_BR`. */
+export type LanguageCode = string;
+/** An asset as the catalog projects it — enough to render and to re-assign it. */
+export interface AssetRef {
+    id: string;
+    name: string;
+    /** A preview URL the asset server scales; absolute or relative to the engine. */
+    preview: string;
+    source: string;
+}
+export interface FacetValueRef {
+    id: string;
+    code: string;
+    name: string;
+    facet: {
+        id: string;
+        code: string;
+        name: string;
+    };
+}
+/**
+ * A product's own availability (the pre-order engine, merged 2026-09-18).
+ *
+ * - `none` — ordinary stock rules.
+ * - `comingSoon` — shown, but nobody can order it, not even from stock.
+ * - `preorder` — customers allowed to backorder may order beyond stock; everyone
+ *   else can still buy what is in stock.
+ */
+export type ProductAvailabilityState = 'none' | 'comingSoon' | 'preorder';
+/** A variant's: the product's states plus `inherit` (use the product's state, date and limit). */
+export type VariantAvailabilityState = 'inherit' | ProductAvailabilityState;
+/**
+ * Availability fields as they are READ. Every writer shares one shape: a state
+ * that is not `inherit` uses this row's own `availableFrom` and `preorderLimit`,
+ * empty ones included.
+ */
+export interface Availability<State extends string> {
+    availabilityState: State;
+    /**
+     * ISO-8601 UTC instant at which the state ends on its own — from then on the
+     * ordinary stock and backorder rules apply again. Null: it ends by hand.
+     */
+    availableFrom: string | null;
+    /**
+     * Under `preorder`: the most units per variant that may be pre-ordered beyond
+     * stock across all open orders. Null: no limit. Ignored under every other
+     * state.
+     */
+    preorderLimit: number | null;
+}
+/**
+ * Availability fields as they are WRITTEN. Omit a field to leave it alone, pass
+ * null to clear it.
+ */
+export interface AvailabilityInput<State extends string> {
+    availabilityState?: State;
+    /**
+     * An ISO-8601 instant WITH an explicit offset (`Z` or `±HH:mm`). One without
+     * is refused before the request leaves (`INVALID_DATETIME`), because the
+     * engine would read it in its own zone, not yours or the store's.
+     */
+    availableFrom?: string | null;
+    /** A whole number ≥ 0, or null for no limit. */
+    preorderLimit?: number | null;
+}
+/**
+ * A price the caller STATES. `basis` says which side of tax the amount is on,
+ * and must equal the store's own (`pricesIncludeTax`): the Admin API stores
+ * one amount in the store's basis and derives the other, so a net amount
+ * written into a gross store would silently lose a whole VAT rate. A mismatch
+ * is refused (`PRICE_BASIS_MISMATCH`) — the SDK never converts, because the
+ * rate that would convert it depends on the zone of each order.
+ */
+export type PriceBasis = 'net' | 'gross';
+/** Omit a key to leave it; unknown keys are not accepted by the Admin API. */
+export interface TranslationInput {
+    languageCode: LanguageCode;
+    /** Present on update to edit that translation row rather than add one. */
+    id?: string;
+}
+/** Vendure's `ConfigurableOperationInput`: a collection filter, a promotion action. */
+export interface ConfigurableOperationInput {
+    code: string;
+    /** Every argument is a STRING on the wire — lists and booleans JSON-encoded. */
+    arguments: Array<{
+        name: string;
+        value: string;
+    }>;
+}
+/** Vendure's `ConfigurableOperation`, as read back. */
+export interface ConfigurableOperation {
+    code: string;
+    args: Array<{
+        name: string;
+        value: string;
+    }>;
+}
+/**
+ * Whose catalogue a row belongs to, as the ACTIVE channel sees it (multi-region spec §5.4):
+ * - `LOCAL` — the store's own row, or a row its organization keeps but has not shared yet.
+ * - `SHARED` — kept by the organization and shared: in a member store, a row of its
+ *   organization's workspace; in the workspace, a row at least one member store holds.
+ *
+ * A string on the wire: a newer engine may answer a state this SDK does not name yet.
+ */
+export type CatalogueOwnershipState = 'LOCAL' | 'SHARED';
+export interface CatalogueOwnership {
+    state: CatalogueOwnershipState | (string & {});
+    /** The organization that keeps the row while it is `SHARED`; null while `LOCAL`. */
+    organizationName: string | null;
+    /**
+     * Whether the caller may change the row from the active channel: it holds the update permission
+     * here and on every other store holding the row, and, in a member store, a `SHARED` row is
+     * changed only in its organization's workspace, by everyone (a write from the store is refused
+     * `MANAGED_BY_ORGANIZATION`). A store's own values on a shared row (its prices, its exclusion)
+     * stay the store's to change. Disable an edit form on `false`; the engine refuses it anyway.
+     */
+    editableHere: boolean;
+}
+/** `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 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
+ * §9.3). Returns the value unchanged — the engine stores the instant, and
+ * re-serialising it here would only risk changing its precision.
+ */
+export declare function assertInstant(field: string, value: string | null | undefined): void;
+/**
+ * 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 declare function availabilityCustomFields<State extends string>(input: AvailabilityInput<State>): Record<string, unknown>;
+/** Vendure's `DeletionResponse`. */
+export interface DeletionResponse {
+    result: 'DELETED' | 'NOT_DELETED';
+    message?: string | null;
+}
+export declare const DELETION_FIELDS = "\n  result\n  message\n";
+/**
+ * `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 declare function assertDeleted(code: string, responses: DeletionResponse[]): void;
+/** Throw a Vendure ErrorResult (`MimeTypeError`, `ProductOptionInUseError`) as itself. */
+export declare function unwrapResult<T>(value: T | {
+    errorCode: string;
+    message: string;
+}): T;
+export declare const DEFAULT_PAGE_SIZE = 25;
+/** Vendure's `adminListQueryLimit` default; a larger `take` is refused by the engine. */
+export declare 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 declare function vendureListPage<W, T = W>(transport: Transport, document: string, field: string, variables: (skip: number, take: number) => Record<string, unknown>, options: ListOptions | undefined, map?: (wire: W) => T): Promise<Page<T>>;
+/**
+ * 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 declare function fieldOf<T>(transport: Transport, document: string, field: string, variables: Record<string, unknown>, options: Call | undefined): Promise<T>;