@sixtyninecommerce/admin 0.8.0 → 0.9.0

package/dist/catalog/products.js

@@ -0,0 +1,365 @@
+import { ValidationError } from '@sixtyninecommerce/core';
+import { bulkProducts, readProductBulkRun, } from './products-bulk.js';
+import { ASSET_REF_FIELDS, assertDeleted, availabilityCustomFields, CATALOGUE_OWNERSHIP_FIELDS, DELETION_FIELDS, FACET_VALUE_REF_FIELDS, fieldOf, unwrapResult, vendureListPage, } from './types.js';
+/** The engine's bound on one `exclude` or `include` call (`STORE_EXCLUSION_BATCH_LIMIT`). */
+export const MAX_STORE_EXCLUSION_PRODUCTS = 500;
+/**
+ * The engine's bounds on one `setAvailabilityInStores` or `availabilityInStores` call
+ * (`AVAILABILITY_*_LIMIT`).
+ */
+export const MAX_AVAILABILITY_PRODUCTS = 100;
+export const MAX_AVAILABILITY_STORES = 50;
+/** The engine's bound on each list of one {@link ProductsModule.setCollections} call. */
+export const MAX_PRODUCT_COLLECTION_IDS = 200;
+export const PRODUCT_FIELDS = /* GraphQL */ `
+  id
+  ${CATALOGUE_OWNERSHIP_FIELDS}
+  createdAt
+  updatedAt
+  languageCode
+  name
+  slug
+  description
+  enabled
+  featuredAsset { ${ASSET_REF_FIELDS} }
+  assets { ${ASSET_REF_FIELDS} }
+  facetValues { ${FACET_VALUE_REF_FIELDS} }
+  optionGroups {
+    id
+    code
+    name
+    options {
+      id
+      code
+      name
+    }
+  }
+  translations {
+    id
+    languageCode
+    name
+    slug
+    description
+  }
+  excludedFromStore
+  variantList(options: { take: 1 }) {
+    totalItems
+  }
+  customFields {
+    availabilityState
+    availableFrom
+    preorderLimit
+  }
+`;
+export const PRODUCTS_QUERY = /* GraphQL */ `
+  query CatalogProducts($options: ProductListOptions) {
+    products(options: $options) {
+      items { ${PRODUCT_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const PRODUCT_QUERY = /* GraphQL */ `
+  query CatalogProduct($id: ID!) {
+    product(id: $id) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const CREATE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogCreateProduct($input: CreateProductInput!) {
+    createProduct(input: $input) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const UPDATE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogUpdateProduct($input: UpdateProductInput!) {
+    updateProduct(input: $input) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const DELETE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogDeleteProduct($id: ID!) {
+    deleteProduct(id: $id) { ${DELETION_FIELDS} }
+  }
+`;
+export const CLONE_PRODUCT_MUTATION = /* GraphQL */ `
+  mutation CatalogCloneProduct($id: ID!) {
+    cloneProduct(id: $id)
+  }
+`;
+export const ADD_OPTION_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogAddOptionGroup($productId: ID!, $optionGroupId: ID!) {
+    addOptionGroupToProduct(productId: $productId, optionGroupId: $optionGroupId) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const REMOVE_OPTION_GROUP_MUTATION = /* GraphQL */ `
+  mutation CatalogRemoveOptionGroup($productId: ID!, $optionGroupId: ID!, $force: Boolean) {
+    removeOptionGroupFromProduct(productId: $productId, optionGroupId: $optionGroupId, force: $force) {
+      ... on Product { ${PRODUCT_FIELDS} }
+      ... on ErrorResult {
+        errorCode
+        message
+      }
+    }
+  }
+`;
+export const EXCLUDE_PRODUCTS_FROM_STORE_MUTATION = /* GraphQL */ `
+  mutation CatalogExcludeProductsFromStore($productIds: [ID!]!) {
+    excludeProductsFromStore(productIds: $productIds) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const INCLUDE_PRODUCTS_IN_STORE_MUTATION = /* GraphQL */ `
+  mutation CatalogIncludeProductsInStore($productIds: [ID!]!) {
+    includeProductsInStore(productIds: $productIds) { ${PRODUCT_FIELDS} }
+  }
+`;
+export const SET_ORGANIZATION_PRODUCT_AVAILABILITY_MUTATION = /* GraphQL */ `
+  mutation CatalogSetOrganizationProductAvailability(
+    $productIds: [ID!]!
+    $channelIds: [ID!]!
+    $available: Boolean!
+  ) {
+    setOrganizationProductAvailability(
+      productIds: $productIds
+      channelIds: $channelIds
+      available: $available
+    ) {
+      productId
+      channelId
+      action
+    }
+  }
+`;
+export const ORGANIZATION_PRODUCT_AVAILABILITY_QUERY = /* GraphQL */ `
+  query CatalogOrganizationProductAvailability($productIds: [ID!]!, $channelIds: [ID!]!) {
+    organizationProductAvailability(productIds: $productIds, channelIds: $channelIds) {
+      productId
+      channelId
+      state
+      localCopyId
+    }
+  }
+`;
+export const MAKE_LOCAL_COPY_MUTATION = /* GraphQL */ `
+  mutation CatalogMakeLocalCopy($productId: ID!, $skus: [LocalCopySkuInput!]) {
+    makeLocalCopy(productId: $productId, skus: $skus) {
+      product { ${PRODUCT_FIELDS} }
+      originalProductId
+      original
+      droppedOrganizationPropertyCount
+    }
+  }
+`;
+export const SET_PRODUCT_COLLECTIONS_MUTATION = /* GraphQL */ `
+  mutation CatalogSetProductCollections(
+    $productId: ID!
+    $collectionIds: [ID!]!
+    $fromCollectionIds: [ID!]
+  ) {
+    setProductCollections(
+      productId: $productId
+      collectionIds: $collectionIds
+      fromCollectionIds: $fromCollectionIds
+    ) {
+      added
+      removed
+      unchanged
+      notRemoved {
+        collectionId
+        reason
+      }
+    }
+  }
+`;
+/**
+ * Lift the availability custom fields to first-class fields. A server older
+ * than the pre-order engine has no such fields and would refuse the document
+ * outright, so the defaults below only cover a NULL value, never an absent one.
+ */
+export function toProduct(wire) {
+    const { variantList, customFields, ...rest } = wire;
+    return {
+        ...rest,
+        variantCount: variantList.totalItems,
+        availabilityState: customFields?.availabilityState ?? 'none',
+        availableFrom: customFields?.availableFrom ?? null,
+        preorderLimit: customFields?.preorderLimit ?? null,
+    };
+}
+function toWireInput(input) {
+    const { availabilityState, availableFrom, preorderLimit, ...rest } = input;
+    const customFields = availabilityCustomFields({
+        availabilityState,
+        availableFrom,
+        preorderLimit,
+    });
+    return Object.keys(customFields).length > 0 ? { ...rest, customFields } : rest;
+}
+export function productFilter(filter) {
+    const out = {};
+    if (!filter)
+        return out;
+    if (filter.ids !== undefined)
+        out.id = { in: filter.ids };
+    if (filter.name !== undefined)
+        out.name = { contains: filter.name };
+    if (filter.sku !== undefined)
+        out.sku = { contains: filter.sku };
+    if (filter.enabled !== undefined)
+        out.enabled = { eq: filter.enabled };
+    if (filter.facetValueIds !== undefined)
+        out.facetValueId = { in: filter.facetValueIds };
+    if (filter.availabilityState !== undefined) {
+        out.availabilityState = { eq: filter.availabilityState };
+    }
+    return out;
+}
+function refuse(code, message) {
+    return new ValidationError({ code, message, status: 400, service: 'vendure' });
+}
+/** Distinct ids the way the engine counts them: it stores a uuid lower-case. */
+function distinctCount(ids) {
+    return new Set(ids.map((id) => String(id).toLowerCase())).size;
+}
+function assertExclusionBatch(productIds) {
+    const count = distinctCount(productIds);
+    if (count <= MAX_STORE_EXCLUSION_PRODUCTS)
+        return;
+    throw refuse('STORE_EXCLUSION_INPUT_INVALID', `Exclude or include at most ${String(MAX_STORE_EXCLUSION_PRODUCTS)} products per call; this one named ${String(count)}. Split it into smaller calls. Nothing was sent.`);
+}
+function assertAvailabilityInput(input, verb = 'set') {
+    const bounds = [
+        ['products', input?.productIds, MAX_AVAILABILITY_PRODUCTS],
+        ['stores', input?.channelIds, MAX_AVAILABILITY_STORES],
+    ];
+    for (const [noun, ids, limit] of bounds) {
+        if (!Array.isArray(ids) || ids.length === 0) {
+            throw refuse('ORGANIZATION_AVAILABILITY_INPUT_INVALID', `Name at least one of the ${noun}. Nothing was sent.`);
+        }
+        const count = distinctCount(ids);
+        if (count > limit) {
+            throw refuse('ORGANIZATION_AVAILABILITY_INPUT_INVALID', `At most ${String(limit)} ${noun} can be ${verb} in one call; this one named ${String(count)}. Split it into smaller calls. Nothing was sent.`);
+        }
+    }
+    if (verb === 'set' && typeof input.available !== 'boolean') {
+        throw refuse('ORGANIZATION_AVAILABILITY_INPUT_INVALID', '`available` must be true (offer the products) or false (stop offering them). Nothing was sent.');
+    }
+}
+/** The engine's check of each list (`PRODUCT_COLLECTIONS_INPUT_INVALID`), before sending. */
+function assertCollectionLists(lists) {
+    for (const [argument, ids] of Object.entries(lists)) {
+        if (ids === undefined)
+            continue;
+        if (!Array.isArray(ids)) {
+            throw refuse('PRODUCT_COLLECTIONS_INPUT_INVALID', `${argument} must be a list of collection ids. Nothing was sent.`);
+        }
+        if (ids.length > MAX_PRODUCT_COLLECTION_IDS) {
+            throw refuse('PRODUCT_COLLECTIONS_INPUT_INVALID', `Name at most ${String(MAX_PRODUCT_COLLECTION_IDS)} collections in ${argument}; this call named ${String(ids.length)}. Nothing was sent.`);
+        }
+        if (distinctCount(ids) !== ids.length) {
+            throw refuse('PRODUCT_COLLECTIONS_INPUT_INVALID', `${argument} names a collection more than once. Name each collection once. Nothing was sent.`);
+        }
+    }
+}
+export function createProductsModule(transport) {
+    const write = async (document, field, variables, options) => {
+        return toProduct(await fieldOf(transport, document, field, variables, options));
+    };
+    return {
+        async list(options) {
+            const filter = productFilter(options?.filter);
+            return vendureListPage(transport, PRODUCTS_QUERY, 'products', (skip, take) => ({
+                options: {
+                    skip,
+                    take,
+                    ...(Object.keys(filter).length > 0 ? { filter, filterOperator: 'AND' } : {}),
+                    ...(options?.sort ? { sort: { [options.sort.field]: options.sort.direction } } : {}),
+                },
+            }), options, toProduct);
+        },
+        async get(id, options) {
+            const product = await fieldOf(transport, PRODUCT_QUERY, 'product', { id }, options);
+            return product ? toProduct(product) : null;
+        },
+        // `async` so every refusal below — including `toWireInput`'s datetime
+        // check — arrives as a rejection, never as a synchronous throw a caller's
+        // `.catch()` would miss.
+        async create(input, options) {
+            if (!Array.isArray(input.translations) || input.translations.length === 0) {
+                throw new ValidationError({
+                    code: 'INVALID_PRODUCT_INPUT',
+                    message: 'A product needs at least one translation (languageCode + name).',
+                    status: 400,
+                    service: 'vendure',
+                });
+            }
+            return write(CREATE_PRODUCT_MUTATION, 'createProduct', { input: toWireInput(input) }, options);
+        },
+        async update(input, options) {
+            return write(UPDATE_PRODUCT_MUTATION, 'updateProduct', { input: toWireInput(input) }, options);
+        },
+        async delete(id, options) {
+            assertDeleted('PRODUCT_NOT_DELETED', [
+                await fieldOf(transport, DELETE_PRODUCT_MUTATION, 'deleteProduct', { id }, options),
+            ]);
+        },
+        async clone(id, options) {
+            return fieldOf(transport, CLONE_PRODUCT_MUTATION, 'cloneProduct', { id }, options);
+        },
+        addOptionGroup(productId, optionGroupId, options) {
+            return write(ADD_OPTION_GROUP_MUTATION, 'addOptionGroupToProduct', { productId, optionGroupId }, options);
+        },
+        async removeOptionGroup(productId, optionGroupId, options) {
+            const result = await fieldOf(transport, REMOVE_OPTION_GROUP_MUTATION, 'removeOptionGroupFromProduct', { productId, optionGroupId, force: options?.force ?? false }, options);
+            return toProduct(unwrapResult(result));
+        },
+        async exclude(productIds, options) {
+            assertExclusionBatch(productIds);
+            if (productIds.length === 0)
+                return [];
+            const rows = await fieldOf(transport, EXCLUDE_PRODUCTS_FROM_STORE_MUTATION, 'excludeProductsFromStore', { productIds }, options);
+            return rows.map(toProduct);
+        },
+        async include(productIds, options) {
+            assertExclusionBatch(productIds);
+            if (productIds.length === 0)
+                return [];
+            const rows = await fieldOf(transport, INCLUDE_PRODUCTS_IN_STORE_MUTATION, 'includeProductsInStore', { productIds }, options);
+            return rows.map(toProduct);
+        },
+        async setAvailabilityInStores(input, options) {
+            assertAvailabilityInput(input);
+            return fieldOf(transport, SET_ORGANIZATION_PRODUCT_AVAILABILITY_MUTATION, 'setOrganizationProductAvailability', {
+                productIds: input.productIds,
+                channelIds: input.channelIds,
+                available: input.available,
+            }, options);
+        },
+        async availabilityInStores(input, options) {
+            assertAvailabilityInput(input, 'read');
+            return fieldOf(transport, ORGANIZATION_PRODUCT_AVAILABILITY_QUERY, 'organizationProductAvailability', { productIds: input.productIds, channelIds: input.channelIds }, options);
+        },
+        async makeLocalCopy(productId, options) {
+            const { skus, ...call } = options ?? {};
+            const result = await fieldOf(transport, MAKE_LOCAL_COPY_MUTATION, 'makeLocalCopy', {
+                productId,
+                skus: skus === undefined
+                    ? null
+                    : skus.map(({ productVariantId, sku }) => ({ productVariantId, sku })),
+            }, call);
+            return { ...result, product: toProduct(result.product) };
+        },
+        async setCollections(productId, collectionIds, options) {
+            const { from, ...call } = options ?? {};
+            assertCollectionLists({ collectionIds, fromCollectionIds: from });
+            return fieldOf(transport, SET_PRODUCT_COLLECTIONS_MUTATION, 'setProductCollections', {
+                productId,
+                collectionIds: [...collectionIds],
+                fromCollectionIds: from === undefined ? null : [...from],
+            }, call);
+        },
+        bulk(input, options) {
+            return bulkProducts(transport, input, options);
+        },
+        bulkRun(runId, options) {
+            return readProductBulkRun(transport, runId, options);
+        },
+    };
+}

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;