@viu/emporix-sdk 2.21.0 → 2.23.0

package/dist/cart.d.ts

@@ -17,6 +17,15 @@ import { C as ClientContext, b as AuthContext } from './context-CfXJcYKP.js';
  *
  */
 type Restriction = string | null;
+type Search = {
+    /**
+     * A standard query parameter is used to search for specific values.
+     *
+     * See: [Standard practises - Query parameter](https://developer.emporix.io/api-references/standard-practices/q-param/)
+     *
+     */
+    q?: string;
+};
 type BaseCart = {
     /**
      * Cart unique identifier generated when a cart is created.
@@ -106,6 +115,16 @@ type BaseCart = {
      */
     nonDelivery?: Array<string>;
 };
+type CartGetAll = BaseCart & {
+    /**
+     * Items added to the cart.
+     */
+    items?: Array<BaseCartItemResponse>;
+    /**
+     * Informs whether cart is still open or it is already closed.
+     */
+    status?: 'OPEN' | 'CLOSED';
+};
 type Cart$1 = BaseCart & {
     /**
      * Items added to the cart.
@@ -180,6 +199,19 @@ type Cart$1 = BaseCart & {
         [key: string]: unknown;
     };
 };
+/**
+ * Cart delivery time restrictions.
+ */
+type CartDtRestrictions = {
+    /**
+     * Time needed to prepare the products for the delivery, expressed in hours. Time is calculated based on the products added to the cart. It is equal to the maximum lead time of all the products - `mixins.productCustomAttributes.leadTime`.
+     */
+    leadTime?: number;
+    /**
+     * List of days on which the products cannot be delivered. Days are presented by numbers where Monday is `0`, Tuesday is `1` etc. `nonDelivery` list is the union of all `mixins.productCustomAttributes.nonDelivery` products values.
+     */
+    nonDelivery?: Array<string>;
+};
 type CartItemRequest = {
     /**
      * Cart item's unique identifier.
@@ -998,6 +1030,40 @@ type SingleBatchResponse = {
     };
     yrn?: Yrn;
 };
+/**
+ * Result for a single cart item in a batch update, aligned with bulk operation entry responses.
+ */
+type UpdateCartItemsBatchEntryResponse = {
+    /**
+     * Index of the processed cart item, matching the position in the request body.
+     *
+     */
+    index?: number;
+    /**
+     * Cart item unique identifier.
+     */
+    id?: string;
+    /**
+     * HTTP status code for this entry.
+     */
+    code?: number;
+    /**
+     * HTTP status description for this entry.
+     */
+    status?: string;
+    /**
+     * Message describing the outcome or error for this entry.
+     */
+    message?: string;
+    /**
+     * Additional detail messages for this entry.
+     */
+    details?: Array<string>;
+};
+/**
+ * Per-entry results for batch cart item updates.
+ */
+type CartItemsBatchUpdateResponse = Array<UpdateCartItemsBatchEntryResponse>;
 /**
  * Shipping cost information.
  */
@@ -1077,6 +1143,63 @@ type Total = {
      */
     discount?: number;
 };
+type UpdateCart = {
+    /**
+     * Customer unique identifier generated when a customer account is created through the Customer Service.
+     */
+    customerId?: string;
+    restriction?: Restriction;
+    /**
+     * Three-letter currency code, compliant with the ISO 4217 standard.
+     */
+    currency?: string;
+    /**
+     * ID of the legal entity to which customer is assigned.
+     */
+    legalEntityId?: string;
+    /**
+     * Delivery window unique identifier, as defined in the Shipping Service.
+     */
+    deliveryWindowId?: string;
+    deliveryWindow?: DeliveryWindow;
+    /**
+     * Cart type. You can use this field if your store offers different types of carts, such as shopping carts and wishlists.
+     */
+    type?: string;
+    /**
+     * Customer address - zip code.
+     */
+    zipCode?: string;
+    /**
+     * Two-letter country code, compliant with the ISO 3166 standard.
+     */
+    countryCode?: string;
+    /**
+     * Order unique identifier generated when a checkout is triggered through the Checkout Service.
+     */
+    orderId?: string;
+    /**
+     * Quote unique identifier generated when a quote is created through the Quote Service out of a cart.
+     */
+    quoteId?: string;
+    /**
+     * Cart status.
+     */
+    status?: 'OPEN' | 'CLOSED';
+    channel?: Channel;
+    /**
+     * External discounts that should be applied to this cart. Requires `cart.cart_manage_external_prices` scope
+     */
+    externalDiscounts?: Array<ExternalCartDiscount>;
+    /**
+     * List of addresses that should be associated with the cart and used for tax determination and shipping cost. There can be one address of type `BILLING` and one of type `SHIPPING` - others are ignored. These addresses are returned with the origin `REQUEST` in the cart response.
+     */
+    addresses?: Array<AddressRequest>;
+    metadata?: MetadataRequest;
+    mixins?: {
+        [key: string]: unknown;
+    };
+};
 type UpdateCartItem = {
     externalFees?: Array<ExternalFee>;
     /**
@@ -1149,6 +1272,9 @@ type UpdateProduct = {
         [key: string]: unknown;
     };
 };
+type CartItemsBatchUpdateRequest = Array<CartItemRequest & {
+    [key: string]: unknown;
+}>;
 type BatchResponse = Array<SingleBatchResponse>;
 /**
  * A unique identifier of a global resource, which stores information about the resource, such as its type, ID or name of the tenant.
@@ -1728,6 +1854,50 @@ type CalculatedTotalDiscount = {
      */
     appliedDiscounts?: Array<CalculatedAppliedDiscount>;
 };
+/**
+ * Result of cart validation showing any errors in the cart items.
+ */
+type CartValidationResult$1 = {
+    /**
+     * Flag indicating if the cart is valid or contains validation errors.
+     */
+    isValid?: boolean;
+    /**
+     * Detailed list of validation errors for specific cart items.
+     */
+    itemsValidationDetails?: Array<ItemValidationDetails>;
+};
+/**
+ * Validation details for a specific cart item.
+ */
+type ItemValidationDetails = {
+    /**
+     * Identifier of the cart item.
+     */
+    id?: string;
+    /**
+     * List of validation errors for this cart item.
+     */
+    errors?: Array<ValidationError>;
+};
+/**
+ * Details of a specific validation error.
+ */
+type ValidationError = {
+    /**
+     * Error code for the validation issue. Common codes include: - CART-ITEM-UNIT-PRICE-100001: Item's price was not found in the price match - CART-ITEM-UNIT-PRICE-100002: Duplicated prices found for the same product - CART-ITEM-EXTERNAL-DISCOUNT-100001: Invalid external discount configuration - CART-ITEM-EXTERNAL-DISCOUNT-100002: External discount amount exceeds item price
+     *
+     */
+    errorCode?: string;
+    /**
+     * Human-readable message describing the error.
+     */
+    message?: string;
+    /**
+     * Field path where the error occurred.
+     */
+    field?: string;
+};
 
 /** A cart as returned by the Cart service (all generated fields). */
 type Cart = Cart$1;
@@ -1743,6 +1913,24 @@ type CartItemBatchEntry = SingleBatchResponse;
 type CartItemsBatchResponse = BatchResponse;
 /** An address payload for cart shipping/billing (generated). */
 type CartAddress = AddressRequest;
+/** Result of validating a cart's items (generated). */
+type CartValidationResult = CartValidationResult$1;
+/** A single cart item as returned by the Cart service (generated). */
+type CartItem = CartItemResponse;
+/** Request body for updating multiple cart items (generated). */
+type CartItemsBatchUpdateInput = CartItemsBatchUpdateRequest;
+/** Per-entry response for a multi-item update (generated). */
+type CartItemsBatchUpdateResult = CartItemsBatchUpdateResponse;
+/** Body for searching carts (`POST /carts/search`) — a `q` filter. */
+type CartSearchInput = Search;
+/** A cart summary as returned by `POST /carts/search`. */
+type CartSummary = CartGetAll;
+/** Body for a full cart update (`PUT /carts/{id}`). */
+type CartUpdateInput = UpdateCart;
+/** A discount entry as returned by `GET /carts/{id}/discounts`. */
+type CartDiscount = DiscountResponse;
+/** Lead-time and non-delivery-time restrictions for a cart (`GET …/dtRestrictions`). */
+type CartDeliveryRestrictions = CartDtRestrictions;
 /** Cart operations. Every method requires an explicit customer/anonymous context. */
 declare class CartService {
     private readonly ctx;
@@ -1807,10 +1995,56 @@ declare class CartService {
      * the updated cart is re-fetched and returned.
      */
     removeCoupon(cartId: string, code: string, auth: AuthContext): Promise<Cart>;
-    /** Sets the shipping address. */
+    /** Validates the cart's items (pricing/consistency checks). */
+    validate(cartId: string, auth: AuthContext): Promise<CartValidationResult>;
+    /** Lists the items in a cart with calculated prices. */
+    listItems(cartId: string, auth: AuthContext): Promise<CartItem[]>;
+    /** Refreshes a cart and its items (re-prices), then returns the updated cart. */
+    refresh(cartId: string, auth: AuthContext): Promise<Cart>;
+    /** Changes the cart's site (re-prices to the new site's currency), then returns the updated cart. */
+    changeSite(cartId: string, siteCode: string, auth: AuthContext): Promise<Cart>;
+    /** Changes the cart's currency (re-prices), then returns the updated cart. */
+    changeCurrency(cartId: string, currency: string, auth: AuthContext): Promise<Cart>;
+    /**
+     * Updates multiple cart items in one request (`PUT …/itemsBatch`). Like
+     * `addItemsBatch`, the response carries a per-entry `status`; partial failures
+     * do not throw — inspect each entry.
+     */
+    updateItemsBatch(cartId: string, items: CartItemsBatchUpdateInput, auth: AuthContext): Promise<CartItemsBatchUpdateResult>;
+    /**
+     * Sets the cart's shipping address, preserving the billing address.
+     *
+     * The API has no per-type address endpoint: addresses live in the cart's
+     * `addresses` array, written via `PUT /carts/{cartId}`. That array is a **full
+     * replace** — sending only one type leaves the other as an empty stub — so
+     * this method reads the cart, merges, writes, and re-fetches. Use
+     * {@link setAddresses} to set both in a single request.
+     */
     setShippingAddress(cartId: string, address: CartAddress, auth: AuthContext): Promise<Cart>;
-    /** Sets the billing address. */
+    /**
+     * Sets the cart's billing address, preserving the shipping address. See
+     * {@link setShippingAddress} for why this reads before writing.
+     */
     setBillingAddress(cartId: string, address: CartAddress, auth: AuthContext): Promise<Cart>;
+    /**
+     * Sets both cart addresses in one request (`PUT /carts/{cartId}`), skipping
+     * the read that {@link setShippingAddress} needs.
+     *
+     * **This replaces the cart's address set**: a type you omit is cleared, and
+     * `{}` clears both. Use it when you already hold both addresses (a checkout
+     * form submitting them together); use the per-type setters to change one and
+     * keep the other.
+     */
+    setAddresses(cartId: string, addresses: {
+        shipping?: CartAddress;
+        billing?: CartAddress;
+    }, auth: AuthContext): Promise<Cart>;
+    /**
+     * Reads the cart, replaces the entry of `type` with `address` (keeping every
+     * other type verbatim — resending it unchanged is what stops the server from
+     * wiping it), writes, and returns the re-fetched cart.
+     */
+    private mergeAddress;
     /**
      * Merges one or more anonymous carts into the specified customer cart.
      * Per Emporix: the target cart in the path **must belong to the logged-in
@@ -1820,6 +2054,50 @@ declare class CartService {
      * Requires a customer `AuthContext`.
      */
     merge(customerCartId: string, anonymousCartIds: string[], auth: AuthContext): Promise<Cart>;
+    /**
+     * Searches carts tenant-wide (`POST /carts/search`, body `{ q }`). This is a
+     * backend/admin operation — a customer token cannot scan other customers'
+     * carts, so `auth` is forwarded unguarded (pass a service token for admin
+     * use). The server enforces scope (403 on insufficient).
+     */
+    search(query: CartSearchInput, auth: AuthContext, params?: {
+        pageNumber?: number;
+        pageSize?: number;
+        sort?: string;
+        fields?: string;
+    }): Promise<CartSummary[]>;
+    /**
+     * Deletes a cart (`DELETE /carts/{cartId}`). Backend/admin or owner
+     * operation — `auth` is forwarded unguarded (service or customer). Returns
+     * nothing; the cart no longer exists.
+     */
+    delete(cartId: string, auth: AuthContext): Promise<void>;
+    /**
+     * Full-updates a cart (`PUT /carts/{cartId}`, body `UpdateCart`). Backend or
+     * owner operation — `auth` is forwarded unguarded. The endpoint returns 204,
+     * so the cart is re-fetched with the same `auth` (via a direct GET, not
+     * `get()`, so a service token is not rejected by the cart-auth guard) and
+     * returned.
+     */
+    update(cartId: string, input: CartUpdateInput, auth: AuthContext): Promise<Cart>;
+    /** Fetches a single cart item's details (`GET /carts/{cartId}/items/{itemId}`). */
+    getItem(cartId: string, itemId: string, auth: AuthContext): Promise<CartItem>;
+    /** Lists the discounts applied to a cart (`GET /carts/{cartId}/discounts`). */
+    listDiscounts(cartId: string, auth: AuthContext): Promise<CartDiscount[]>;
+    /**
+     * Removes all discounts from a cart (`DELETE /carts/{cartId}/discounts` with
+     * no `codes` filter), then re-fetches and returns the updated cart. Use
+     * `removeCoupon(code)` to remove a specific coupon by code.
+     */
+    removeAllDiscounts(cartId: string, auth: AuthContext): Promise<Cart>;
+    /**
+     * Removes a single discount by its index (`DELETE
+     * /carts/{cartId}/discounts/{discountIndex}`), then re-fetches and returns
+     * the updated cart.
+     */
+    removeDiscountByIndex(cartId: string, discountIndex: string, auth: AuthContext): Promise<Cart>;
+    /** Retrieves the cart's lead-time and non-delivery-time restrictions (`GET /carts/{cartId}/dtRestrictions`). */
+    getDeliveryRestrictions(cartId: string, auth: AuthContext): Promise<CartDeliveryRestrictions>;
 }
 
-export { type Cart, type CartAddress, type CartCreated, type CartItemBatchEntry, type CartItemInput, type CartItemUpdate, type CartItemsBatchResponse, CartService, type CreateCartInput };
+export { type Cart, type CartAddress, type CartCreated, type CartDeliveryRestrictions, type CartDiscount, type CartItem, type CartItemBatchEntry, type CartItemInput, type CartItemUpdate, type CartItemsBatchResponse, type CartItemsBatchUpdateInput, type CartItemsBatchUpdateResult, type CartSearchInput, CartService, type CartSummary, type CartUpdateInput, type CartValidationResult, type CreateCartInput };

package/dist/cart.js

@@ -1,4 +1,4 @@
-export { CartService } from './chunk-HUEMYP2L.js';
+export { CartService } from './chunk-YVZ6GOLE.js';
 import './chunk-UWGGF4MC.js';
 //# sourceMappingURL=cart.js.map
 //# sourceMappingURL=cart.js.map

package/dist/category.cjs

@@ -14,7 +14,7 @@ async function* iterateAll(fetchPage, start = 1) {
 // src/core/query.ts
 function resolveQuery(q, cap) {
   if (typeof q === "string") return q;
-  if (q.usesCompound === true && true) {
+  if (q.usesCompound === true && !cap.compoundLogicalQuery) {
     throw new Error(
       "This filter uses or()/compoundLogicalQuery, which the target service does not support. Combine conditions with and() (space-separated AND) instead."
     );
@@ -57,7 +57,7 @@ var CategoryService = class {
    * support `compoundLogicalQuery`, so `or()` filters are rejected.
    */
   async search(query, params = {}, auth = ANON) {
-    const q = resolveQuery(query);
+    const q = resolveQuery(query, { compoundLogicalQuery: false });
     const pageNumber = params.pageNumber ?? 1;
     const pageSize = params.pageSize ?? 50;
     const items = await this.ctx.http.request({
@@ -174,6 +174,224 @@ var CategoryService = class {
     );
     return pages.flat();
   }
+  /** Lists a category's ancestor categories (breadcrumb-up). Default auth: anonymous. */
+  async parents(categoryId, auth = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/parents`,
+      auth
+    });
+  }
+  /**
+   * Lists a category's direct child categories via the dedicated
+   * `…/subcategories` endpoint. (The older `subcategories()` reads `/assignments`
+   * and is kept for backward compatibility.) Default auth: anonymous.
+   */
+  async childCategories(categoryId, auth = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/subcategories`,
+      auth
+    });
+  }
+  /** Retrieves one category tree by its root category id. Default auth: anonymous. */
+  async getTree(categoryId, auth = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/category/${this.ctx.tenant}/category-trees/${encodeURIComponent(categoryId)}`,
+      auth
+    });
+  }
+  // --- Admin write CRUD. Default auth: service. ---
+  /**
+   * Creates a category (`POST /categories`). Default auth: service.
+   * `options.publish` sets the `publish` query flag (needs the
+   * `category.category_publish` scope).
+   */
+  async create(input, options = {}, auth = SERVICE) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/category/${this.ctx.tenant}/categories`,
+      ...options.publish === void 0 ? {} : { query: { publish: String(options.publish) } },
+      body: input,
+      auth
+    });
+  }
+  /**
+   * Full-replaces a category (`PUT /categories/{categoryId}`). This is an
+   * upsert: with a caller-supplied id it may create (201, returns the id) or
+   * update an existing one (204, returns nothing). Default auth: service.
+   */
+  async update(categoryId, input, options = {}, auth = SERVICE) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}`,
+      ...options.publish === void 0 ? {} : { query: { publish: String(options.publish) } },
+      body: input,
+      auth
+    });
+  }
+  /**
+   * Partially updates a category (`PATCH /categories/{categoryId}`). Default
+   * auth: service. `options.publish` sets the `publish` query flag.
+   */
+  async patch(categoryId, input, options = {}, auth = SERVICE) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}`,
+      ...options.publish === void 0 ? {} : { query: { publish: String(options.publish) } },
+      body: input,
+      auth
+    });
+  }
+  /** Deletes a category (`DELETE /categories/{categoryId}`). Default auth: service. */
+  async delete(categoryId, auth = SERVICE) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}`,
+      auth
+    });
+  }
+  /**
+   * Searches categories via `POST /categories/search`. Same query capability
+   * as {@link search} (`compoundLogicalQuery: false` — Category rejects `or()`
+   * filters); the POST body avoids URL-length limits for large `q` filters.
+   * `params.showRoots` / `params.showUnpublished` are POST-only flags. Default
+   * auth: anonymous.
+   */
+  async searchByQuery(query, params = {}, auth = ANON) {
+    const q = resolveQuery(query, { compoundLogicalQuery: false });
+    const pageNumber = params.pageNumber ?? 1;
+    const pageSize = params.pageSize ?? 50;
+    const items = await this.ctx.http.request({
+      method: "POST",
+      path: `/category/${this.ctx.tenant}/categories/search`,
+      query: {
+        pageNumber,
+        pageSize,
+        ...params.sort === void 0 ? {} : { sort: params.sort },
+        ...params.showRoots === void 0 ? {} : { showRoots: String(params.showRoots) },
+        ...params.showUnpublished === void 0 ? {} : { showUnpublished: String(params.showUnpublished) }
+      },
+      body: { q },
+      idempotent: true,
+      // pure read over POST — safe to replay on 5xx/429
+      auth
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  /**
+   * Searches category trees via `POST /category-trees/search` — returns the
+   * trees that include at least one of the given `categoryIds`. Default auth:
+   * anonymous.
+   */
+  async searchTrees(input, options = {}, auth = ANON) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/category/${this.ctx.tenant}/category-trees/search`,
+      ...options.showUnpublished === void 0 ? {} : { query: { showUnpublished: String(options.showUnpublished) } },
+      body: input,
+      idempotent: true,
+      // pure read over POST — safe to replay on 5xx/429
+      auth
+    });
+  }
+  /**
+   * Category ↔ resource assignments. Writes default to service auth. The
+   * assignment `ref.type` is `'PRODUCT'` (per the API); category hierarchy is
+   * managed via `parentId` on the category, not via assignments.
+   */
+  assignments = {
+    /** One page of a category's assignments. Default auth: anonymous. */
+    list: async (categoryId, params = {}, auth = ANON) => this.ctx.http.request({
+      method: "GET",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments`,
+      query: {
+        ...params.pageNumber === void 0 ? {} : { pageNumber: params.pageNumber },
+        ...params.pageSize === void 0 ? {} : { pageSize: params.pageSize },
+        ...params.sort === void 0 ? {} : { sort: params.sort },
+        ...params.expandSupercategoriesIds === void 0 ? {} : { expandSupercategoriesIds: String(params.expandSupercategoriesIds) },
+        ...params.showUnpublished === void 0 ? {} : { showUnpublished: String(params.showUnpublished) }
+      },
+      auth
+    }),
+    /** Assigns a single resource to a category (`POST …/assignments`). Default auth: service. */
+    create: async (categoryId, input, auth = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments`,
+      body: input,
+      auth
+    }),
+    /** Bulk-assigns resources to a category (`POST …/assignments/bulk`). Default auth: service. */
+    bulkCreate: async (categoryId, input, auth = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/bulk`,
+      body: input,
+      auth
+    }),
+    /** Removes one assignment by id (`DELETE …/assignments/{assignmentId}`). Default auth: service. */
+    remove: async (categoryId, assignmentId, auth = SERVICE) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/${assignmentId}`,
+        auth
+      });
+    },
+    /** Removes all of a category's assignments (`DELETE …/assignments`). Default auth: service. */
+    removeAll: async (categoryId, options = {}, auth = SERVICE) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments`,
+        ...options.assignmentType === void 0 ? {} : { query: { assignmentType: options.assignmentType } },
+        auth
+      });
+    },
+    /** Upserts an assignment by reference id — no body (`PUT …/assignments/references/{referenceId}`). Default auth: service. */
+    upsertByReference: async (categoryId, referenceId, auth = SERVICE) => this.ctx.http.request({
+      method: "PUT",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/references/${referenceId}`,
+      auth
+    }),
+    /** Removes an assignment by reference id (`DELETE …/assignments/references/{referenceId}`). Default auth: service. */
+    removeByReference: async (categoryId, referenceId, auth = SERVICE) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/references/${referenceId}`,
+        auth
+      });
+    },
+    /** Bulk-upserts assignment references (`PUT …/assignments/references/bulk`). Default auth: service. */
+    bulkUpsertByReference: async (categoryId, input, auth = SERVICE) => this.ctx.http.request({
+      method: "PUT",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/references/bulk`,
+      body: input,
+      auth
+    }),
+    /**
+     * Lists every category assigned to the given reference id — tenant-wide
+     * (`GET /assignments/references/{referenceId}`). Default auth: anonymous.
+     */
+    listCategoriesByReference: async (referenceId, params = {}, auth = ANON) => this.ctx.http.request({
+      method: "GET",
+      path: `/category/${this.ctx.tenant}/assignments/references/${referenceId}`,
+      query: {
+        ...params.pageNumber === void 0 ? {} : { pageNumber: params.pageNumber },
+        ...params.pageSize === void 0 ? {} : { pageSize: params.pageSize },
+        ...params.sort === void 0 ? {} : { sort: params.sort },
+        ...params.showUnpublished === void 0 ? {} : { showUnpublished: String(params.showUnpublished) },
+        ...params.expandSupercategoriesIds === void 0 ? {} : { expandSupercategoriesIds: String(params.expandSupercategoriesIds) }
+      },
+      auth
+    }),
+    /** Removes all assignments to a given reference id — tenant-wide (`DELETE /assignments/references/{referenceId}`). Default auth: service. */
+    removeAllByReference: async (referenceId, auth = SERVICE) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/assignments/references/${referenceId}`,
+        auth
+      });
+    }
+  };
 };
 
 exports.CategoryService = CategoryService;