@viu/emporix-sdk 2.22.0 → 2.23.0

package/dist/index.cjs

@@ -886,7 +886,7 @@ var HttpClient = class {
 };
 
 // package.json
-var version = "2.22.0";
+var version = "2.23.0";
 
 // src/version.ts
 var SDK_VERSION = version;
@@ -1247,6 +1247,7 @@ function resolveQuery(q, cap) {
 
 // src/services/product.ts
 var ANON = { kind: "anonymous" };
+var SERVICE = { kind: "service" };
 var ProductService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -1410,11 +1411,200 @@ var ProductService = class {
     }
     return out;
   }
+  // --- Admin writes. Default auth: service. ---
+  /**
+   * Creates a product (`POST /products`). Default auth: service. Accepts any of
+   * the five product shapes (basic, bundle, parent-variant, variant,
+   * dynamic-variant).
+   */
+  async create(input, options = {}, auth2 = SERVICE) {
+    const query = {
+      ...options.skipVariantGeneration === void 0 ? {} : { skipVariantGeneration: String(options.skipVariantGeneration) },
+      ...options.doIndex === void 0 ? {} : { doIndex: String(options.doIndex) },
+      ...options.skipRelatedItemsValidation === void 0 ? {} : { skipRelatedItemsValidation: String(options.skipRelatedItemsValidation) }
+    };
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/product/${this.ctx.tenant}/products`,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Partially updates a product (`PATCH /products/{productId}`). Default auth:
+   * service. Use {@link replace} for a full replace (PUT).
+   */
+  async update(productId, input, options = {}, auth2 = SERVICE) {
+    const query = {
+      ...options.skipVariantGeneration === void 0 ? {} : { skipVariantGeneration: String(options.skipVariantGeneration) },
+      ...options.doIndex === void 0 ? {} : { doIndex: String(options.doIndex) },
+      ...options.skipRelatedItemsValidation === void 0 ? {} : { skipRelatedItemsValidation: String(options.skipRelatedItemsValidation) }
+    };
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `/product/${this.ctx.tenant}/products/${productId}`,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Full-replaces a product (`PUT /products/{productId}`). Returns the created
+   * resource on 201 (upsert) and nothing on 204. `options.partial` sends
+   * `?partial=true` for a merge-style replace. Default auth: service.
+   */
+  async replace(productId, input, options = {}, auth2 = SERVICE) {
+    const query = {
+      ...options.partial === void 0 ? {} : { partial: String(options.partial) },
+      ...options.skipVariantGeneration === void 0 ? {} : { skipVariantGeneration: String(options.skipVariantGeneration) },
+      ...options.doIndex === void 0 ? {} : { doIndex: String(options.doIndex) },
+      ...options.skipRelatedItemsValidation === void 0 ? {} : { skipRelatedItemsValidation: String(options.skipRelatedItemsValidation) }
+    };
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `/product/${this.ctx.tenant}/products/${productId}`,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Deletes a product (`DELETE /products/{productId}`). `options.force` deletes
+   * even when the product is referenced. Default auth: service.
+   */
+  async delete(productId, options = {}, auth2 = SERVICE) {
+    const query = {
+      ...options.force === void 0 ? {} : { force: String(options.force) },
+      ...options.doIndex === void 0 ? {} : { doIndex: String(options.doIndex) }
+    };
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `/product/${this.ctx.tenant}/products/${productId}`,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      auth: auth2
+    });
+  }
+  /**
+   * Bulk-creates products (`POST /products/bulk`). Responds 207 Multi-Status:
+   * partial failures do **not** throw — inspect each entry. Default auth: service.
+   */
+  async bulkCreate(input, options = {}, auth2 = SERVICE) {
+    const query = {
+      ...options.skipVariantGeneration === void 0 ? {} : { skipVariantGeneration: String(options.skipVariantGeneration) },
+      ...options.doIndex === void 0 ? {} : { doIndex: String(options.doIndex) },
+      ...options.skipRelatedItemsValidation === void 0 ? {} : { skipRelatedItemsValidation: String(options.skipRelatedItemsValidation) }
+    };
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/product/${this.ctx.tenant}/products/bulk`,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Bulk-updates products (`PUT /products/bulk`). Responds 207 Multi-Status:
+   * partial failures do **not** throw — inspect each entry. Default auth: service.
+   */
+  async bulkUpdate(input, options = {}, auth2 = SERVICE) {
+    const query = {
+      ...options.skipVariantGeneration === void 0 ? {} : { skipVariantGeneration: String(options.skipVariantGeneration) },
+      ...options.doIndex === void 0 ? {} : { doIndex: String(options.doIndex) },
+      ...options.skipRelatedItemsValidation === void 0 ? {} : { skipRelatedItemsValidation: String(options.skipRelatedItemsValidation) }
+    };
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `/product/${this.ctx.tenant}/products/bulk`,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Triggers a dynamic-variant recalculation for the given product ids
+   * (`POST /products/recalculate`, 202). The result carries the created or
+   * already-referenced `jobs` plus `skippedProductIds` — products whose root
+   * already has a PENDING/PROCESSING job. Default auth: service.
+   */
+  async recalculate(input, auth2 = SERVICE) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/product/${this.ctx.tenant}/products/recalculate`,
+      body: input,
+      auth: auth2
+    });
+  }
+  /** Lists dynamic-variant recalculation jobs, optionally filtered by status. Default auth: anonymous. */
+  async listRecalculationJobs(params = {}, auth2 = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/product/${this.ctx.tenant}/products/recalculate/jobs`,
+      ...params.status === void 0 ? {} : { query: { status: params.status } },
+      auth: auth2
+    });
+  }
+  /** Fetches one dynamic-variant recalculation job by id. Default auth: anonymous. */
+  async getRecalculationJob(jobId, auth2 = ANON) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/product/${this.ctx.tenant}/products/recalculate/jobs/${jobId}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Product templates (`/product-templates`). Reads default to anonymous,
+   * writes to service auth.
+   */
+  templates = {
+    /** One page of product templates. Default auth: anonymous. */
+    list: async (params = {}, auth2 = ANON) => this.ctx.http.request({
+      method: "GET",
+      path: `/product/${this.ctx.tenant}/product-templates`,
+      query: {
+        ...params.pageNumber === void 0 ? {} : { pageNumber: params.pageNumber },
+        ...params.pageSize === void 0 ? {} : { pageSize: params.pageSize },
+        ...params.sort === void 0 ? {} : { sort: params.sort },
+        ...params.q === void 0 ? {} : { q: params.q }
+      },
+      auth: auth2
+    }),
+    /** Fetches one product template by id. Default auth: anonymous. */
+    get: async (templateId, auth2 = ANON) => this.ctx.http.request({
+      method: "GET",
+      path: `/product/${this.ctx.tenant}/product-templates/${templateId}`,
+      auth: auth2
+    }),
+    /** Creates a product template. Default auth: service. */
+    create: async (input, auth2 = SERVICE) => this.ctx.http.request({
+      method: "POST",
+      path: `/product/${this.ctx.tenant}/product-templates`,
+      body: input,
+      auth: auth2
+    }),
+    /** Full-replaces a product template (`PUT`). Default auth: service. */
+    update: async (templateId, input, auth2 = SERVICE) => {
+      await this.ctx.http.request({
+        method: "PUT",
+        path: `/product/${this.ctx.tenant}/product-templates/${templateId}`,
+        body: input,
+        auth: auth2
+      });
+    },
+    /** Deletes a product template. Default auth: service. */
+    delete: async (templateId, auth2 = SERVICE) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/product/${this.ctx.tenant}/product-templates/${templateId}`,
+        auth: auth2
+      });
+    }
+  };
 };
 
 // src/services/category.ts
 var ANON2 = { kind: "anonymous" };
-var SERVICE = { kind: "service" };
+var SERVICE2 = { kind: "service" };
 var CategoryService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -1479,7 +1669,7 @@ var CategoryService = class {
    * Rebuild a category tree from its root (`POST /category-trees/{rootCategoryId}/rebuild`).
    * Admin write — defaults to the service token. Returns the rebuilt tree.
    */
-  async rebuildTree(rootCategoryId, auth2 = SERVICE) {
+  async rebuildTree(rootCategoryId, auth2 = SERVICE2) {
     return this.ctx.http.request({
       method: "POST",
       path: `/category/${this.ctx.tenant}/category-trees/${encodeURIComponent(rootCategoryId)}/rebuild`,
@@ -1592,6 +1782,196 @@ var CategoryService = class {
       auth: auth2
     });
   }
+  // --- 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 = {}, auth2 = SERVICE2) {
+    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: auth2
+    });
+  }
+  /**
+   * 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 = {}, auth2 = SERVICE2) {
+    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: auth2
+    });
+  }
+  /**
+   * Partially updates a category (`PATCH /categories/{categoryId}`). Default
+   * auth: service. `options.publish` sets the `publish` query flag.
+   */
+  async patch(categoryId, input, options = {}, auth2 = SERVICE2) {
+    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: auth2
+    });
+  }
+  /** Deletes a category (`DELETE /categories/{categoryId}`). Default auth: service. */
+  async delete(categoryId, auth2 = SERVICE2) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}`,
+      auth: auth2
+    });
+  }
+  /**
+   * 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 = {}, auth2 = ANON2) {
+    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: auth2
+    });
+    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 = {}, auth2 = ANON2) {
+    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: auth2
+    });
+  }
+  /**
+   * 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 = {}, auth2 = ANON2) => 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: auth2
+    }),
+    /** Assigns a single resource to a category (`POST …/assignments`). Default auth: service. */
+    create: async (categoryId, input, auth2 = SERVICE2) => this.ctx.http.request({
+      method: "POST",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments`,
+      body: input,
+      auth: auth2
+    }),
+    /** Bulk-assigns resources to a category (`POST …/assignments/bulk`). Default auth: service. */
+    bulkCreate: async (categoryId, input, auth2 = SERVICE2) => this.ctx.http.request({
+      method: "POST",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/bulk`,
+      body: input,
+      auth: auth2
+    }),
+    /** Removes one assignment by id (`DELETE …/assignments/{assignmentId}`). Default auth: service. */
+    remove: async (categoryId, assignmentId, auth2 = SERVICE2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/${assignmentId}`,
+        auth: auth2
+      });
+    },
+    /** Removes all of a category's assignments (`DELETE …/assignments`). Default auth: service. */
+    removeAll: async (categoryId, options = {}, auth2 = SERVICE2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments`,
+        ...options.assignmentType === void 0 ? {} : { query: { assignmentType: options.assignmentType } },
+        auth: auth2
+      });
+    },
+    /** Upserts an assignment by reference id — no body (`PUT …/assignments/references/{referenceId}`). Default auth: service. */
+    upsertByReference: async (categoryId, referenceId, auth2 = SERVICE2) => this.ctx.http.request({
+      method: "PUT",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/references/${referenceId}`,
+      auth: auth2
+    }),
+    /** Removes an assignment by reference id (`DELETE …/assignments/references/{referenceId}`). Default auth: service. */
+    removeByReference: async (categoryId, referenceId, auth2 = SERVICE2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/references/${referenceId}`,
+        auth: auth2
+      });
+    },
+    /** Bulk-upserts assignment references (`PUT …/assignments/references/bulk`). Default auth: service. */
+    bulkUpsertByReference: async (categoryId, input, auth2 = SERVICE2) => this.ctx.http.request({
+      method: "PUT",
+      path: `/category/${this.ctx.tenant}/categories/${categoryId}/assignments/references/bulk`,
+      body: input,
+      auth: auth2
+    }),
+    /**
+     * Lists every category assigned to the given reference id — tenant-wide
+     * (`GET /assignments/references/{referenceId}`). Default auth: anonymous.
+     */
+    listCategoriesByReference: async (referenceId, params = {}, auth2 = ANON2) => 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: auth2
+    }),
+    /** Removes all assignments to a given reference id — tenant-wide (`DELETE /assignments/references/{referenceId}`). Default auth: service. */
+    removeAllByReference: async (referenceId, auth2 = SERVICE2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/category/${this.ctx.tenant}/assignments/references/${referenceId}`,
+        auth: auth2
+      });
+    }
+  };
 };
 
 // src/services/cart.ts
@@ -1807,23 +2187,62 @@ var CartService = class {
       body: items
     });
   }
-  /** Sets the shipping address. */
+  /**
+   * 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.
+   */
   async setShippingAddress(cartId, address, auth2) {
-    return this.ctx.http.request({
+    return this.mergeAddress(cartId, address, "SHIPPING", requireCartAuth(auth2));
+  }
+  /**
+   * Sets the cart's billing address, preserving the shipping address. See
+   * {@link setShippingAddress} for why this reads before writing.
+   */
+  async setBillingAddress(cartId, address, auth2) {
+    return this.mergeAddress(cartId, address, "BILLING", requireCartAuth(auth2));
+  }
+  /**
+   * 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.
+   */
+  async setAddresses(cartId, addresses, auth2) {
+    const cartAuth = requireCartAuth(auth2);
+    const next = [];
+    if (addresses.shipping) next.push({ ...addresses.shipping, type: "SHIPPING" });
+    if (addresses.billing) next.push({ ...addresses.billing, type: "BILLING" });
+    await this.ctx.http.request({
       method: "PUT",
-      path: `${this.base()}/${cartId}/shipping-address`,
-      auth: requireCartAuth(auth2),
-      body: address
+      path: `${this.base()}/${cartId}`,
+      auth: cartAuth,
+      body: { addresses: next }
     });
+    return this.get(cartId, cartAuth);
   }
-  /** Sets the billing address. */
-  async setBillingAddress(cartId, address, auth2) {
-    return this.ctx.http.request({
+  /**
+   * 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.
+   */
+  async mergeAddress(cartId, address, type, cartAuth) {
+    const current = await this.get(cartId, cartAuth);
+    const others = (current.addresses ?? []).filter((a) => a.type !== type);
+    await this.ctx.http.request({
       method: "PUT",
-      path: `${this.base()}/${cartId}/billing-address`,
-      auth: requireCartAuth(auth2),
-      body: address
+      path: `${this.base()}/${cartId}`,
+      auth: cartAuth,
+      body: { addresses: [...others, { ...address, type }] }
     });
+    return this.get(cartId, cartAuth);
   }
   /**
    * Merges one or more anonymous carts into the specified customer cart.
@@ -1841,18 +2260,124 @@ var CartService = class {
       body: { carts: anonymousCartIds }
     });
   }
-};
-
-// src/services/checkout.ts
-function isGuest(customer) {
-  return customer?.guest === true;
-}
-function resolveAuth(auth2, guest) {
-  if (auth2 && (auth2.kind === "customer" || auth2.kind === "raw")) return auth2;
-  if (guest && auth2 && auth2.kind === "anonymous") return auth2;
-  throw new EmporixAuthError(
-    "checkout requires a customer/raw AuthContext (or anonymous for a guest checkout)"
-  );
+  /**
+   * 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).
+   */
+  async search(query, auth2, params = {}) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/search`,
+      query: {
+        ...params.pageNumber === void 0 ? {} : { pageNumber: params.pageNumber },
+        ...params.pageSize === void 0 ? {} : { pageSize: params.pageSize },
+        ...params.sort === void 0 ? {} : { sort: params.sort },
+        ...params.fields === void 0 ? {} : { fields: params.fields }
+      },
+      body: query,
+      idempotent: true,
+      // pure read over POST — safe to replay on 5xx/429
+      auth: auth2
+    });
+  }
+  /**
+   * 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.
+   */
+  async delete(cartId, auth2) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${cartId}`,
+      auth: auth2
+    });
+  }
+  /**
+   * 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.
+   */
+  async update(cartId, input, auth2) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${cartId}`,
+      auth: auth2,
+      body: input
+    });
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${cartId}`,
+      auth: auth2
+    });
+  }
+  /** Fetches a single cart item's details (`GET /carts/{cartId}/items/{itemId}`). */
+  async getItem(cartId, itemId, auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${cartId}/items/${itemId}`,
+      auth: requireCartAuth(auth2)
+    });
+  }
+  /** Lists the discounts applied to a cart (`GET /carts/{cartId}/discounts`). */
+  async listDiscounts(cartId, auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${cartId}/discounts`,
+      auth: requireCartAuth(auth2)
+    });
+  }
+  /**
+   * 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.
+   */
+  async removeAllDiscounts(cartId, auth2) {
+    const cartAuth = requireCartAuth(auth2);
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${cartId}/discounts`,
+      auth: cartAuth
+    });
+    return this.get(cartId, cartAuth);
+  }
+  /**
+   * Removes a single discount by its index (`DELETE
+   * /carts/{cartId}/discounts/{discountIndex}`), then re-fetches and returns
+   * the updated cart.
+   */
+  async removeDiscountByIndex(cartId, discountIndex, auth2) {
+    const cartAuth = requireCartAuth(auth2);
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${cartId}/discounts/${discountIndex}`,
+      auth: cartAuth
+    });
+    return this.get(cartId, cartAuth);
+  }
+  /** Retrieves the cart's lead-time and non-delivery-time restrictions (`GET /carts/{cartId}/dtRestrictions`). */
+  async getDeliveryRestrictions(cartId, auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${cartId}/dtRestrictions`,
+      auth: requireCartAuth(auth2)
+    });
+  }
+};
+
+// src/services/checkout.ts
+function isGuest(customer) {
+  return customer?.guest === true;
+}
+function resolveAuth(auth2, guest) {
+  if (auth2 && (auth2.kind === "customer" || auth2.kind === "raw")) return auth2;
+  if (guest && auth2 && auth2.kind === "anonymous") return auth2;
+  throw new EmporixAuthError(
+    "checkout requires a customer/raw AuthContext (or anonymous for a guest checkout)"
+  );
 }
 var CheckoutService = class {
   constructor(ctx) {
@@ -1898,6 +2423,7 @@ var CheckoutService = class {
 
 // src/services/payment.ts
 var ANON3 = auth.anonymous();
+var SERVICE3 = auth.service();
 var PaymentGatewayService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -1942,6 +2468,112 @@ var PaymentGatewayService = class {
       body: input
     });
   }
+  /**
+   * Payment-mode **configuration** (`/paymentmodes/config`) — the admin view.
+   * For the storefront view use {@link listPaymentModes} / {@link getMode}.
+   * Defaults to service auth.
+   */
+  modes = {
+    /** Lists all configured payment modes. The endpoint takes no query parameters. */
+    list: async (authCtx = SERVICE3) => this.ctx.http.request({
+      method: "GET",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config`,
+      auth: authCtx
+    }),
+    /** Retrieves one payment-mode configuration by id. */
+    get: async (id, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "GET",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config/${id}`,
+      auth: authCtx
+    }),
+    /** Creates a payment-mode configuration. Responds 200 with the created mode. */
+    create: async (input, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config`,
+      body: input,
+      auth: authCtx
+    }),
+    /** Updates a payment-mode configuration (PUT). Responds 200 with the updated mode. */
+    update: async (id, input, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "PUT",
+      path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config/${id}`,
+      body: input,
+      auth: authCtx
+    }),
+    /** Deletes a payment-mode configuration. */
+    delete: async (id, authCtx = SERVICE3) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/payment-gateway/${this.ctx.tenant}/paymentmodes/config/${id}`,
+        auth: authCtx
+      });
+    }
+  };
+  /**
+   * Backend transaction lifecycle and reads. `authorize` creates the transaction
+   * that `capture`/`refund`/`cancel` then act on. Business failures are reported
+   * in the response body (`successful: false`), not as HTTP errors — always check
+   * `successful`. Defaults to service auth.
+   */
+  transactions = {
+    /** One page of payment transactions. */
+    list: async (params = {}, authCtx = SERVICE3) => {
+      const query = {
+        ...params.pageNumber === void 0 ? {} : { pageNumber: params.pageNumber },
+        ...params.pageSize === void 0 ? {} : { pageSize: params.pageSize },
+        ...params.sort === void 0 ? {} : { sort: params.sort }
+      };
+      return this.ctx.http.request({
+        method: "GET",
+        path: `/payment-gateway/${this.ctx.tenant}/transactions`,
+        ...Object.keys(query).length > 0 ? { query } : {},
+        auth: authCtx
+      });
+    },
+    /** Retrieves one payment transaction by id. */
+    get: async (transactionId, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "GET",
+      path: `/payment-gateway/${this.ctx.tenant}/transactions/${transactionId}`,
+      auth: authCtx
+    }),
+    /**
+     * Authorizes a payment as a backend caller (`POST /payment/authorize`). The
+     * storefront equivalent is {@link PaymentGatewayService.authorize}, which
+     * targets `/payment/frontend/authorize` with a customer token.
+     */
+    authorize: async (input, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/authorize`,
+      body: input,
+      auth: authCtx
+    }),
+    /**
+     * Captures an authorized payment. Omit `input` to capture the full
+     * authorized amount. Returns the provider's `captureId` on success.
+     */
+    capture: async (transactionId, input, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/${transactionId}/capture`,
+      ...input === void 0 ? {} : { body: input },
+      auth: authCtx
+    }),
+    /**
+     * Refunds a captured payment. Omit `input` to refund the full captured
+     * amount; pass `captureId` when several captures exist for the payment.
+     */
+    refund: async (transactionId, input, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/${transactionId}/refund`,
+      ...input === void 0 ? {} : { body: input },
+      auth: authCtx
+    }),
+    /** Cancels an authorized payment. Takes no body. */
+    cancel: async (transactionId, authCtx = SERVICE3) => this.ctx.http.request({
+      method: "POST",
+      path: `/payment-gateway/${this.ctx.tenant}/payment/${transactionId}/cancel`,
+      auth: authCtx
+    })
+  };
 };
 
 // src/services/price.ts
@@ -1956,7 +2588,7 @@ function normalizeMatch(raw) {
   return { ...base, itemId, itemRef };
 }
 var ANON4 = { kind: "anonymous" };
-var SERVICE2 = { kind: "service" };
+var SERVICE4 = { kind: "service" };
 function requireContextAuth(auth2) {
   const a = auth2 ?? ANON4;
   if (a.kind === "anonymous" || a.kind === "customer" || a.kind === "raw") return a;
@@ -1990,7 +2622,7 @@ var PriceService = class {
    * Resolves prices from an explicit context. Default auth: service
    * (requires `price.price_read` / `price.price_manage`).
    */
-  async match(input, auth2 = SERVICE2) {
+  async match(input, auth2 = SERVICE4) {
     const rows = await this.ctx.http.request({
       method: "POST",
       path: `/price/${this.ctx.tenant}/match-prices`,
@@ -2045,10 +2677,207 @@ var PriceService = class {
     await Promise.all(Array.from({ length: workerCount }, () => worker()));
     return results.flat();
   }
+  // --- Admin CRUD (flat prices). Default auth: service. ---
+  /** Creates a flat price. Default auth: service. */
+  async create(input, authCtx = SERVICE4) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/prices`,
+      auth: authCtx,
+      body: input
+    });
+  }
+  /** Lists flat prices. Default auth: service. */
+  async list(query, authCtx = SERVICE4) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/prices`,
+      auth: authCtx,
+      ...query ? { query } : {}
+    });
+  }
+  /** Retrieves one flat price by id. Default auth: service. */
+  async get(priceId, authCtx = SERVICE4) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/prices/${priceId}`,
+      auth: authCtx
+    });
+  }
+  /** Upserts a flat price by id (PUT). Default auth: service. */
+  async upsert(priceId, input, authCtx = SERVICE4) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `/price/${this.ctx.tenant}/prices/${priceId}`,
+      auth: authCtx,
+      body: input
+    });
+  }
+  /** Deletes a flat price by id. Default auth: service. */
+  async delete(priceId, authCtx = SERVICE4) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `/price/${this.ctx.tenant}/prices/${priceId}`,
+      auth: authCtx
+    });
+  }
+  /** Searches flat prices (POST body query). Default auth: service. */
+  async search(query, authCtx = SERVICE4) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/prices/search`,
+      auth: authCtx,
+      body: query
+    });
+  }
+  /** Creates multiple flat prices in one request. Default auth: service. */
+  async bulkCreate(inputs, authCtx = SERVICE4) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/prices/bulk`,
+      auth: authCtx,
+      body: inputs
+    });
+  }
+  /** Upserts multiple flat prices in one request (PUT). Default auth: service. */
+  async bulkUpsert(inputs, authCtx = SERVICE4) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `/price/${this.ctx.tenant}/prices/bulk`,
+      auth: authCtx,
+      body: inputs
+    });
+  }
+  /** Price-model admin CRUD (`/priceModels`). Default auth: service. */
+  models = {
+    list: async (query, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/priceModels`,
+      auth: authCtx,
+      ...query ? { query } : {}
+    }),
+    create: async (input, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/priceModels`,
+      auth: authCtx,
+      body: input
+    }),
+    get: async (modelId, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/priceModels/${modelId}`,
+      auth: authCtx
+    }),
+    upsert: async (modelId, input, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "PUT",
+      path: `/price/${this.ctx.tenant}/priceModels/${modelId}`,
+      auth: authCtx,
+      body: input
+    }),
+    delete: async (modelId, authCtx = SERVICE4) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/price/${this.ctx.tenant}/priceModels/${modelId}`,
+        auth: authCtx
+      });
+    }
+  };
+  /** Price-list admin CRUD (`/price-lists`) + nested price management. Default auth: service. */
+  lists = {
+    list: async (query, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/price-lists`,
+      auth: authCtx,
+      ...query ? { query } : {}
+    }),
+    create: async (input, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/price-lists`,
+      auth: authCtx,
+      body: input
+    }),
+    search: async (query, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/price-lists/search`,
+      auth: authCtx,
+      body: query
+    }),
+    get: async (listId, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}`,
+      auth: authCtx
+    }),
+    upsert: async (listId, input, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "PUT",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}`,
+      auth: authCtx,
+      body: input
+    }),
+    delete: async (listId, authCtx = SERVICE4) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/price/${this.ctx.tenant}/price-lists/${listId}`,
+        auth: authCtx
+      });
+    },
+    listPrices: async (listId, query, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices`,
+      auth: authCtx,
+      ...query ? { query } : {}
+    }),
+    addPrice: async (listId, input, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices`,
+      auth: authCtx,
+      body: input
+    }),
+    getPrice: async (listId, priceId, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "GET",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices/${priceId}`,
+      auth: authCtx
+    }),
+    upsertPrice: async (listId, priceId, input, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "PUT",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices/${priceId}`,
+      auth: authCtx,
+      body: input
+    }),
+    deletePrice: async (listId, priceId, authCtx = SERVICE4) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices/${priceId}`,
+        auth: authCtx
+      });
+    },
+    searchPrices: async (listId, query, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices/search`,
+      auth: authCtx,
+      body: query
+    }),
+    bulkCreatePrices: async (listId, inputs, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "POST",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices/bulk`,
+      auth: authCtx,
+      body: inputs
+    }),
+    bulkUpsertPrices: async (listId, inputs, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "PUT",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices/bulk`,
+      auth: authCtx,
+      body: inputs
+    }),
+    bulkDeletePrices: async (listId, body, authCtx = SERVICE4) => this.ctx.http.request({
+      method: "DELETE",
+      path: `/price/${this.ctx.tenant}/price-lists/${listId}/prices/bulk`,
+      auth: authCtx,
+      body
+    })
+  };
 };
 
 // src/services/media.ts
-var SERVICE3 = { kind: "service" };
+var SERVICE5 = { kind: "service" };
 function isProductRef(r, productId) {
   return r.type === "PRODUCT" && r.id === productId;
 }
@@ -2062,7 +2891,7 @@ var MediaService = class {
     return `/media/${this.ctx.tenant}/assets`;
   }
   /** Create an asset. BLOB uploads via multipart; LINK via JSON. */
-  async create(input, auth2 = SERVICE3) {
+  async create(input, auth2 = SERVICE5) {
     if (input.kind === "blob") {
       const fd = new FormData();
       fd.set("file", input.file);
@@ -2089,7 +2918,7 @@ var MediaService = class {
    * defaults match Emporix's server defaults (`pageNumber: 1`,
    * `pageSize: 60`) so an empty `query` produces stable expectations.
    */
-  async list(query = {}, auth2 = SERVICE3) {
+  async list(query = {}, auth2 = SERVICE5) {
     const pageNumber = query.pageNumber ?? 1;
     const pageSize = query.pageSize ?? 60;
     const items = await this.ctx.http.request({
@@ -2106,7 +2935,7 @@ var MediaService = class {
     };
   }
   /** Fetch an asset by id. */
-  async get(assetId, auth2 = SERVICE3) {
+  async get(assetId, auth2 = SERVICE5) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${assetId}`,
@@ -2127,7 +2956,7 @@ var MediaService = class {
    * existing asset's values. Optimistic-locking is via `body.metadata.version`;
    * the server returns 409 Conflict on a stale version.
    */
-  async update(assetId, input, auth2 = SERVICE3) {
+  async update(assetId, input, auth2 = SERVICE5) {
     if (input.kind === "blob") {
       const fd = new FormData();
       fd.set("file", input.file);
@@ -2147,7 +2976,7 @@ var MediaService = class {
     });
   }
   /** Remove an asset. */
-  async remove(assetId, auth2 = SERVICE3) {
+  async remove(assetId, auth2 = SERVICE5) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/${assetId}`,
@@ -2173,7 +3002,7 @@ var MediaService = class {
    * direct storage URL for `PUBLIC` `BLOB` assets (typically delivered via
    * an `<img>` tag rather than `download()`).
    */
-  async download(assetId, auth2 = SERVICE3) {
+  async download(assetId, auth2 = SERVICE5) {
     const path = `${this.base()}/${assetId}/download`;
     const res = await this.ctx.http.requestRaw(
       { method: "GET", path, auth: auth2 },
@@ -2221,7 +3050,7 @@ var MediaService = class {
     throw errorFromResponse(res.status, `GET ${path} \u2192 ${res.status}`, parsed);
   }
   /** Multipart upload sugar: builds `AssetCreateBlob` from input. */
-  async uploadFile(input, auth2 = SERVICE3) {
+  async uploadFile(input, auth2 = SERVICE5) {
     const body = {
       type: "BLOB",
       access: input.access ?? "PUBLIC",
@@ -2242,7 +3071,7 @@ var MediaService = class {
    * Pass `version` from `asset.metadata.version` if you want optimistic
    * locking (recommended when concurrent writers are possible).
    */
-  async replaceFile(assetId, input, auth2 = SERVICE3) {
+  async replaceFile(assetId, input, auth2 = SERVICE5) {
     const body = {
       type: "BLOB",
       access: input.access,
@@ -2257,7 +3086,7 @@ var MediaService = class {
     return this.update(assetId, { kind: "blob", file: input.file, body }, auth2);
   }
   /** External-URL sugar: builds `AssetCreateLink`. */
-  async link(input, auth2 = SERVICE3) {
+  async link(input, auth2 = SERVICE5) {
     const body = {
       type: "LINK",
       access: input.access ?? "PUBLIC",
@@ -2267,7 +3096,7 @@ var MediaService = class {
     return this.create({ kind: "link", body }, auth2);
   }
   /** Idempotently add a PRODUCT refId to an asset. */
-  async attachToProduct(assetId, productId, auth2 = SERVICE3) {
+  async attachToProduct(assetId, productId, auth2 = SERVICE5) {
     const a = await this.get(assetId, auth2);
     const refIds = a.refIds ?? [];
     if (refIds.some((r) => isProductRef(r, productId))) return a;
@@ -2276,7 +3105,7 @@ var MediaService = class {
     return this.update(assetId, { kind: "json", body: patch }, auth2);
   }
   /** Remove a PRODUCT refId from an asset (no-op if absent). */
-  async detachFromProduct(assetId, productId, auth2 = SERVICE3) {
+  async detachFromProduct(assetId, productId, auth2 = SERVICE5) {
     const a = await this.get(assetId, auth2);
     const refIds = a.refIds ?? [];
     const next = refIds.filter((r) => !isProductRef(r, productId));
@@ -2285,7 +3114,7 @@ var MediaService = class {
     return this.update(assetId, { kind: "json", body: patch }, auth2);
   }
   /** Convenience: list assets attached to a product (server-side filter). */
-  async listForProduct(productId, auth2 = SERVICE3) {
+  async listForProduct(productId, auth2 = SERVICE5) {
     return this.list({ "refIds.id": productId }, auth2);
   }
 };
@@ -2296,6 +3125,7 @@ function setIfDefined(q, key, value) {
     q[key] = value;
   }
 }
+var SERVICE6 = { kind: "service" };
 var SegmentService = class {
   constructor(ctx, deps) {
     this.ctx = ctx;
@@ -2427,10 +3257,189 @@ var SegmentService = class {
     const items = await this.deps.categories.searchByIds(ids, void 0, auth2);
     return { items, pageNumber, pageSize, hasNextPage: sourceItems.length === pageSize };
   }
+  // --- Admin CRUD (segment_manage). Default auth: service. ---
+  /** Creates a segment. Default auth: service. */
+  async create(input, authCtx = SERVICE6) {
+    return this.ctx.http.request({ method: "POST", path: this.base(), auth: authCtx, body: input });
+  }
+  /** Searches segments (POST body). Default auth: service. */
+  async search(query, authCtx = SERVICE6) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/search`,
+      auth: authCtx,
+      body: query
+    });
+  }
+  /** Full-replaces a segment (PUT). Default auth: service. */
+  async update(segmentId, input, authCtx = SERVICE6) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${segmentId}`,
+      auth: authCtx,
+      body: input
+    });
+  }
+  /** Partially updates a segment (PATCH). Default auth: service. */
+  async patch(segmentId, input, authCtx = SERVICE6) {
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/${segmentId}`,
+      auth: authCtx,
+      body: input
+    });
+  }
+  /** Deletes a segment. Default auth: service. */
+  async delete(segmentId, authCtx = SERVICE6) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${segmentId}`,
+      auth: authCtx
+    });
+  }
+  /** Checks which segments the given items/customers match. Default auth: service. */
+  async match(input, authCtx = SERVICE6) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/match`,
+      auth: authCtx,
+      body: input
+    });
+  }
+  /** Creates multiple segments. Default auth: service. */
+  async bulkCreate(inputs, authCtx = SERVICE6) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/bulk`,
+      auth: authCtx,
+      body: inputs
+    });
+  }
+  /** Upserts multiple segments (PUT). Default auth: service. */
+  async bulkUpdate(inputs, authCtx = SERVICE6) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/bulk`,
+      auth: authCtx,
+      body: inputs
+    });
+  }
+  /** Deletes multiple segments (DELETE with a body of ids). Default auth: service. */
+  async bulkDelete(body, authCtx = SERVICE6) {
+    return this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/bulk`,
+      auth: authCtx,
+      body
+    });
+  }
+  /** Customer→segment assignments (`segment_manage`). Default auth: service. */
+  customers = {
+    list: async (segmentId, query, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${segmentId}/customers`,
+      auth: authCtx,
+      ...query ? { query } : {}
+    }),
+    search: async (segmentId, query, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/${segmentId}/customers/search`,
+      auth: authCtx,
+      body: query
+    }),
+    get: async (segmentId, customerId, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${segmentId}/customers/${customerId}`,
+      auth: authCtx
+    }),
+    assign: async (segmentId, customerId, input, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${segmentId}/customers/${customerId}`,
+      auth: authCtx,
+      body: input
+    }),
+    remove: async (segmentId, customerId, authCtx = SERVICE6) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/${segmentId}/customers/${customerId}`,
+        auth: authCtx
+      });
+    },
+    getForEntity: async (segmentId, customerId, legalEntityId, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${segmentId}/customers/${customerId}/${legalEntityId}`,
+      auth: authCtx
+    }),
+    assignForEntity: async (segmentId, customerId, legalEntityId, input, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${segmentId}/customers/${customerId}/${legalEntityId}`,
+      auth: authCtx,
+      body: input
+    }),
+    removeForEntity: async (segmentId, customerId, legalEntityId, authCtx = SERVICE6) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/${segmentId}/customers/${customerId}/${legalEntityId}`,
+        auth: authCtx
+      });
+    },
+    bulkAssign: async (segmentId, inputs, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${segmentId}/customers/bulk`,
+      auth: authCtx,
+      body: inputs
+    }),
+    bulkRemove: async (segmentId, body, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${segmentId}/customers/bulk`,
+      auth: authCtx,
+      body
+    })
+  };
+  /** Item→segment assignments (`type` = PRODUCT | CATEGORY). Default auth: service. */
+  items = {
+    search: async (segmentId, query, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/${segmentId}/items/search`,
+      auth: authCtx,
+      body: query
+    }),
+    get: async (segmentId, type, itemId, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${segmentId}/items/${type}/${itemId}`,
+      auth: authCtx
+    }),
+    assign: async (segmentId, type, itemId, input, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${segmentId}/items/${type}/${itemId}`,
+      auth: authCtx,
+      body: input
+    }),
+    remove: async (segmentId, type, itemId, authCtx = SERVICE6) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/${segmentId}/items/${type}/${itemId}`,
+        auth: authCtx
+      });
+    },
+    bulkAssign: async (segmentId, type, inputs, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${segmentId}/items/${type}/bulk`,
+      auth: authCtx,
+      body: inputs
+    }),
+    bulkRemove: async (segmentId, type, body, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${segmentId}/items/${type}/bulk`,
+      auth: authCtx,
+      body
+    })
+  };
 };
 
 // src/services/site.ts
 var ANON5 = auth.anonymous();
+var SERVICE7 = auth.service();
 var SiteService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -2467,6 +3476,114 @@ var SiteService = class {
     }
     return def;
   }
+  /** Lists just the tenant's site codes (`GET /siteslist`). Default auth: anonymous. */
+  async listCodes(authCtx = ANON5) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/site/${this.ctx.tenant}/siteslist`,
+      auth: authCtx
+    });
+  }
+  // --- Admin writes. Default auth: service. ---
+  /** Creates a site (`POST /sites`). Default auth: service. */
+  async create(input, authCtx = SERVICE7) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/site/${this.ctx.tenant}/sites`,
+      body: input,
+      auth: authCtx
+    });
+  }
+  /**
+   * Partially updates a site (`PATCH /sites/{siteCode}`). The endpoint responds
+   * 200 without a defined body, so nothing is returned — re-read with
+   * {@link get} when the updated site is needed. Default auth: service.
+   */
+  async update(siteCode, input, authCtx = SERVICE7) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `/site/${this.ctx.tenant}/sites/${siteCode}`,
+      body: input,
+      auth: authCtx
+    });
+  }
+  /**
+   * Full-replaces a site (`PUT /sites/{siteCode}`). Like {@link update} it
+   * returns nothing (200 with no defined body). `options.expand` is forwarded as
+   * a query parameter. Default auth: service.
+   */
+  async replace(siteCode, input, options = {}, authCtx = SERVICE7) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `/site/${this.ctx.tenant}/sites/${siteCode}`,
+      ...options.expand === void 0 ? {} : { query: { expand: options.expand } },
+      body: input,
+      auth: authCtx
+    });
+  }
+  /** Deletes a site (`DELETE /sites/{siteCode}`). Default auth: service. */
+  async delete(siteCode, authCtx = SERVICE7) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `/site/${this.ctx.tenant}/sites/${siteCode}`,
+      auth: authCtx
+    });
+  }
+  /**
+   * Site mixins (`/sites/{siteCode}/mixins`). Mixin content is an open map —
+   * the spec defines no structure. Reads default to anonymous, writes to
+   * service auth.
+   */
+  mixins = {
+    /** All mixin groups of a site, as a map of group name to content. */
+    list: async (siteCode, authCtx = ANON5) => this.ctx.http.request({
+      method: "GET",
+      path: `/site/${this.ctx.tenant}/sites/${siteCode}/mixins`,
+      auth: authCtx
+    }),
+    /** One mixin group's content by name. */
+    get: async (siteCode, mixinName, authCtx = ANON5) => this.ctx.http.request({
+      method: "GET",
+      path: `/site/${this.ctx.tenant}/sites/${siteCode}/mixins/${mixinName}`,
+      auth: authCtx
+    }),
+    /** Adds a mixin to a site. Default auth: service. */
+    create: async (siteCode, input, authCtx = SERVICE7) => this.ctx.http.request({
+      method: "POST",
+      path: `/site/${this.ctx.tenant}/sites/${siteCode}/mixins`,
+      body: input,
+      auth: authCtx
+    }),
+    /**
+     * Partially updates a mixin (PATCH). Responds 200 without a defined body,
+     * so nothing is returned. Default auth: service.
+     */
+    update: async (siteCode, mixinName, input, authCtx = SERVICE7) => {
+      await this.ctx.http.request({
+        method: "PATCH",
+        path: `/site/${this.ctx.tenant}/sites/${siteCode}/mixins/${mixinName}`,
+        body: input,
+        auth: authCtx
+      });
+    },
+    /** Full-replaces a mixin (PUT). Returns nothing, like {@link update}. Default auth: service. */
+    replace: async (siteCode, mixinName, input, authCtx = SERVICE7) => {
+      await this.ctx.http.request({
+        method: "PUT",
+        path: `/site/${this.ctx.tenant}/sites/${siteCode}/mixins/${mixinName}`,
+        body: input,
+        auth: authCtx
+      });
+    },
+    /** Removes a mixin from a site. Default auth: service. */
+    delete: async (siteCode, mixinName, authCtx = SERVICE7) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `/site/${this.ctx.tenant}/sites/${siteCode}/mixins/${mixinName}`,
+        auth: authCtx
+      });
+    }
+  };
 };
 
 // src/services/session-context.ts
@@ -2599,11 +3716,36 @@ var CompaniesService = class {
       body: patch
     });
   }
-  /** Deletes a legal entity (async cascade on the server). */
-  async delete(legalEntityId, auth2) {
-    await this.ctx.http.request({
-      method: "DELETE",
-      path: `${this.base()}/${legalEntityId}`,
+  /** Deletes a legal entity (async cascade on the server). */
+  async delete(legalEntityId, auth2) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${legalEntityId}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Searches legal entities via `POST /legal-entities/search` with an Emporix
+   * `q`-syntax filter body. Requires the same read scope as {@link listMine}.
+   */
+  async search(query, auth2) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/search`,
+      auth: auth2,
+      body: query,
+      idempotent: true
+      // pure read over POST — safe to replay on 5xx/429
+    });
+  }
+  /**
+   * Retrieves a legal entity's chain of parent entities
+   * (`GET /legal-entities/{id}/parent-hierarchy`).
+   */
+  async parentHierarchy(legalEntityId, auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${legalEntityId}/parent-hierarchy`,
       auth: auth2
     });
   }
@@ -2659,6 +3801,14 @@ var ContactsService = class {
       auth: auth2
     });
   }
+  /** Fetches a single contact assignment by id. */
+  async get(contactAssignmentId, auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${contactAssignmentId}`,
+      auth: auth2
+    });
+  }
 };
 
 // src/services/locations.ts
@@ -2721,39 +3871,222 @@ var LocationsService = class {
   }
 };
 
-// src/services/customer-groups.ts
-var CustomerGroupsService = class {
+// src/services/iam.ts
+var IamService = class {
   constructor(ctx) {
     this.ctx = ctx;
   }
   ctx;
   static channel = "iam";
   base() {
-    return `/iam/${this.ctx.tenant}/groups`;
+    return `/iam/${this.ctx.tenant}`;
   }
-  /** Lists customer groups belonging to one legal entity. */
-  async listForCompany(legalEntityId, auth2) {
-    return this.ctx.http.request({
+  users = {
+    list: async (auth2, query) => this.ctx.http.request({
       method: "GET",
-      path: this.base(),
-      query: { "b2b.legalEntityId": legalEntityId },
+      path: `${this.base()}/users`,
+      auth: auth2,
+      ...query ? { query } : {}
+    }),
+    create: async (input, auth2) => this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/users`,
+      auth: auth2,
+      body: input
+    }),
+    get: async (userId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/users/${userId}`,
       auth: auth2
-    });
+    }),
+    getMe: async (auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/users/me`,
+      auth: auth2
+    }),
+    update: async (userId, input, auth2) => {
+      await this.ctx.http.request({
+        method: "PUT",
+        path: `${this.base()}/users/${userId}`,
+        auth: auth2,
+        body: input
+      });
+    },
+    delete: async (userId, auth2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/users/${userId}`,
+        auth: auth2
+      });
+    },
+    getGroups: async (userId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/users/${userId}/groups`,
+      auth: auth2
+    }),
+    getScopes: async (userId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/users/${userId}/scopes`,
+      auth: auth2
+    }),
+    getMyScopes: async (auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/users/me/scopes`,
+      auth: auth2
+    }),
+    getAccessControls: async (userId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/users/${userId}/access-controls`,
+      auth: auth2
+    }),
+    getMyAccessControls: async (auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/users/me/access-controls`,
+      auth: auth2
+    })
+  };
+  groups = {
+    list: async (auth2, query) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/groups`,
+      auth: auth2,
+      ...query ? { query } : {}
+    }),
+    create: async (input, auth2) => this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/groups`,
+      auth: auth2,
+      body: input
+    }),
+    get: async (groupId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/groups/${groupId}`,
+      auth: auth2
+    }),
+    update: async (groupId, input, auth2) => {
+      await this.ctx.http.request({
+        method: "PUT",
+        path: `${this.base()}/groups/${groupId}`,
+        auth: auth2,
+        body: input
+      });
+    },
+    delete: async (groupId, auth2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/groups/${groupId}`,
+        auth: auth2
+      });
+    },
+    listUsers: async (groupId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/groups/${groupId}/users`,
+      auth: auth2
+    }),
+    addUser: async (groupId, input, auth2) => this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/groups/${groupId}/users`,
+      auth: auth2,
+      body: input
+    }),
+    updateUser: async (groupId, userType, userId, input, auth2) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/groups/${groupId}/users/${userType}/${userId}`,
+      auth: auth2,
+      body: input
+    }),
+    removeAllUsers: async (groupId, auth2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/groups/${groupId}/users`,
+        auth: auth2
+      });
+    },
+    listAccessControls: async (groupId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/groups/${groupId}/access-controls`,
+      auth: auth2
+    })
+  };
+  accessControls = {
+    list: async (auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/access-controls`,
+      auth: auth2
+    }),
+    get: async (id, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/access-controls/${id}`,
+      auth: auth2
+    }),
+    upsert: async (id, input, auth2) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/access-controls/${id}`,
+      auth: auth2,
+      body: input
+    }),
+    delete: async (id, auth2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/access-controls/${id}`,
+        auth: auth2
+      });
+    }
+  };
+  scopes = {
+    list: async (auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/scopes`,
+      auth: auth2
+    }),
+    get: async (scopeId, auth2) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/scopes/${scopeId}`,
+      auth: auth2
+    }),
+    upsertCustom: async (scopeId, input, auth2) => this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/scopes/${scopeId}`,
+      auth: auth2,
+      body: input
+    }),
+    deleteCustom: async (scopeId, auth2) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/scopes/${scopeId}`,
+        auth: auth2
+      });
+    }
+  };
+};
+
+// src/services/customer-groups.ts
+var CustomerGroupsService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.iam = new IamService(ctx);
+  }
+  ctx;
+  static channel = "iam";
+  iam;
+  /** Lists customer groups belonging to one legal entity. */
+  async listForCompany(legalEntityId, auth2) {
+    return this.iam.groups.list(auth2, { "b2b.legalEntityId": legalEntityId });
   }
   /** Adds a user (customer or employee) to a group. */
   async addMember(groupId, member, auth2) {
-    return this.ctx.http.request({
-      method: "POST",
-      path: `${this.base()}/${groupId}/users`,
-      auth: auth2,
-      body: member
-    });
+    return await this.iam.groups.addUser(groupId, member, auth2);
   }
-  /** Removes a user from a group. */
+  /**
+   * Removes a user from a group. Uses `DELETE …/groups/{groupId}/users/{userId}`
+   * directly — this endpoint is deprecated upstream and intentionally not
+   * exposed on {@link IamService}, so it is not delegated. No non-deprecated
+   * single-user removal exists.
+   */
   async removeMember(groupId, userId, auth2) {
     await this.ctx.http.request({
       method: "DELETE",
-      path: `${this.base()}/${groupId}/users/${userId}`,
+      path: `/iam/${this.ctx.tenant}/groups/${groupId}/users/${userId}`,
       auth: auth2
     });
   }
@@ -2828,6 +4161,42 @@ var OrdersService = class {
   async cancel(orderId, auth2, opts = {}) {
     await this.transition(orderId, "DECLINED", auth2, opts);
   }
+  /**
+   * Lists a legal entity's orders (`GET /legal-entity-orders/{legalEntityId}`),
+   * wrapped into `PaginatedItems`. B2B storefront view — requires a customer
+   * token with access to the legal entity.
+   */
+  async listForLegalEntity(legalEntityId, auth2, opts = {}) {
+    const pageNumber = opts.pageNumber ?? 1;
+    const pageSize = opts.pageSize ?? 50;
+    const query = { pageNumber, pageSize };
+    setIfDefined2(query, "sort", opts.sort);
+    if (opts.q !== void 0) {
+      setIfDefined2(query, "q", resolveQuery(opts.q, { compoundLogicalQuery: false }));
+    }
+    const headers = this.saasHeader(opts.saasToken);
+    const items = await this.ctx.http.request({
+      method: "GET",
+      path: `/order-v2/${this.ctx.tenant}/legal-entity-orders/${legalEntityId}`,
+      query,
+      auth: auth2,
+      ...headers ? { headers } : {}
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  /**
+   * Fetches one order within a legal entity
+   * (`GET /legal-entity-orders/{legalEntityId}/{orderId}`).
+   */
+  async getForLegalEntity(legalEntityId, orderId, auth2, opts = {}) {
+    const headers = this.saasHeader(opts.saasToken);
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/order-v2/${this.ctx.tenant}/legal-entity-orders/${legalEntityId}/${orderId}`,
+      auth: auth2,
+      ...headers ? { headers } : {}
+    });
+  }
 };
 var SalesOrdersService = class {
   constructor(ctx) {
@@ -2838,30 +4207,153 @@ var SalesOrdersService = class {
   base() {
     return `/order-v2/${this.ctx.tenant}/salesorders`;
   }
-  /** Fetches a single sales-order by id. */
-  async get(orderId, auth2) {
+  /** Fetches a single sales-order by id. */
+  async get(orderId, auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${orderId}`,
+      auth: auth2
+    });
+  }
+  /** Patches an existing order (status, mixins, customAttributes, metadata). */
+  async update(orderId, patch, auth2, opts = {}) {
+    const query = {};
+    if (opts.recalculate === false) query.recalculate = "false";
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/${orderId}`,
+      auth: auth2,
+      ...Object.keys(query).length > 0 ? { query } : {},
+      body: patch
+    });
+  }
+  /** Lists tenant sales-orders (`GET /salesorders`), wrapped into `PaginatedItems`. */
+  async list(auth2, opts = {}) {
+    const pageNumber = opts.pageNumber ?? 1;
+    const pageSize = opts.pageSize ?? 50;
+    const query = { pageNumber, pageSize };
+    setIfDefined2(query, "sort", opts.sort);
+    setIfDefined2(query, "fields", opts.fields);
+    if (opts.q !== void 0) {
+      setIfDefined2(query, "q", resolveQuery(opts.q, { compoundLogicalQuery: false }));
+    }
+    const items = await this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      query,
+      auth: auth2
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  /** Searches tenant sales-orders (`POST /salesorders/search`, body carries the `q` filter). */
+  async search(query, auth2, opts = {}) {
+    const q = {};
+    setIfDefined2(q, "pageNumber", opts.pageNumber);
+    setIfDefined2(q, "pageSize", opts.pageSize);
+    setIfDefined2(q, "sort", opts.sort);
+    setIfDefined2(q, "fields", opts.fields);
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/search`,
+      ...Object.keys(q).length > 0 ? { query: q } : {},
+      body: query,
+      idempotent: true,
+      // pure read over POST — safe to replay on 5xx/429
+      auth: auth2
+    });
+  }
+  /** Creates a sales-order as an employee (`POST /salesorders`). Returns the created resource location. */
+  async create(input, auth2) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(),
+      auth: auth2,
+      body: input
+    });
+  }
+  /**
+   * Full-replaces a sales-order (`PUT /salesorders/{orderId}`, body `OrderUpdateDto`).
+   * The endpoint returns 204, so the order is re-fetched (direct GET) and returned.
+   * Note: `update` on this class is the PATCH (partial); `replace` is the PUT (full).
+   */
+  async replace(orderId, input, auth2) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${orderId}`,
+      auth: auth2,
+      body: input
+    });
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${orderId}`,
+      auth: auth2
+    });
+  }
+  /** Deletes a sales-order (`DELETE /salesorders/{orderId}`). */
+  async delete(orderId, auth2) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${orderId}`,
+      auth: auth2
+    });
+  }
+  /** Lists the available transitions for a sales-order (`GET /salesorders/{orderId}/transitions`). */
+  async listTransitions(orderId, auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${orderId}/transitions`,
+      auth: auth2
+    });
+  }
+  /** Transitions a sales-order to a new status (`POST /salesorders/{orderId}/transitions`). */
+  async transition(orderId, input, auth2) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/${orderId}/transitions`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Lists the historical transitions of a sales-order (`GET /salesorders/{orderId}/historical-transitions`). */
+  async listHistoricalTransitions(orderId, auth2) {
     return this.ctx.http.request({
       method: "GET",
-      path: `${this.base()}/${orderId}`,
+      path: `${this.base()}/${orderId}/historical-transitions`,
       auth: auth2
     });
   }
-  /** Patches an existing order (status, mixins, customAttributes, metadata). */
-  async update(orderId, patch, auth2, opts = {}) {
-    const query = {};
-    if (opts.recalculate === false) query.recalculate = "false";
+  /** Calculates order-entry totals for a sales-order (`POST /salesorders/{orderId}/calculations`). */
+  async calculate(orderId, input, auth2) {
     return this.ctx.http.request({
-      method: "PATCH",
-      path: `${this.base()}/${orderId}`,
+      method: "POST",
+      path: `${this.base()}/${orderId}/calculations`,
       auth: auth2,
-      ...Object.keys(query).length > 0 ? { query } : {},
-      body: patch
+      body: input
+    });
+  }
+  /** Updates a sales-order's entries (`POST /salesorders/{orderId}/entries`). Returns the updated order. */
+  async updateEntries(orderId, input, auth2) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/${orderId}/entries`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Splits a sales-order (`POST /salesorders/{orderId}/split`). */
+  async split(orderId, input, auth2) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/${orderId}/split`,
+      auth: auth2,
+      body: input
     });
   }
 };
 
 // src/services/availability.ts
 var ANON7 = { kind: "anonymous" };
+var SERVICE8 = { kind: "service" };
 var AvailabilityService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -2916,10 +4408,127 @@ var AvailabilityService = class {
       }
     );
   }
+  /**
+   * Lists every availability record for a site (`GET /availability/site/{site}`),
+   * wrapped into `PaginatedItems`. Default auth: anonymous.
+   */
+  async listForSite(siteCode, params = {}, auth2 = ANON7) {
+    const pageNumber = params.pageNumber ?? 1;
+    const pageSize = params.pageSize ?? 50;
+    const items = await this.ctx.http.request({
+      method: "GET",
+      path: `/availability/${this.ctx.tenant}/availability/site/${encodeURIComponent(siteCode)}`,
+      query: {
+        pageNumber,
+        pageSize,
+        ...params.q === void 0 ? {} : { q: params.q },
+        ...params.sort === void 0 ? {} : { sort: params.sort }
+      },
+      auth: auth2
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  // --- Admin writes. Default auth: service. ---
+  /**
+   * Creates an availability record for a product on a site
+   * (`POST /availability/{productId}/{site}`). Responds 409 when the record
+   * already exists — use {@link update} to upsert. Default auth: service.
+   */
+  async create(productId, siteCode, input, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/availability/${this.ctx.tenant}/availability/${encodeURIComponent(
+        productId
+      )}/${encodeURIComponent(siteCode)}`,
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Upserts a product's availability on a site
+   * (`PUT /availability/{productId}/{site}`). Returns the created record's id
+   * on 201 and nothing on 204. This endpoint has no PATCH counterpart.
+   * Default auth: service.
+   */
+  async update(productId, siteCode, input, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `/availability/${this.ctx.tenant}/availability/${encodeURIComponent(
+        productId
+      )}/${encodeURIComponent(siteCode)}`,
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Deletes a product's availability on a site
+   * (`DELETE /availability/{productId}/{site}`). Default auth: service.
+   */
+  async delete(productId, siteCode, auth2 = SERVICE8) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `/availability/${this.ctx.tenant}/availability/${encodeURIComponent(
+        productId
+      )}/${encodeURIComponent(siteCode)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Bulk-creates availability records (`POST /availability/bulk`). Responds 207
+   * Multi-Status: partial failures do **not** throw — inspect each entry.
+   *
+   * `options.vendorId` limits the operation to a vendor's products. It is sent
+   * as the `vendor-id` header. **Note:** the OpenAPI schema spells this header
+   * `venodr-id`, which is an evident upstream typo (the body field is
+   * `vendorId`); the SDK sends the corrected name. Unverified against the live
+   * API — if the service really expects the misspelling, the filter silently
+   * has no effect.
+   *
+   * Default auth: service.
+   */
+  async bulkCreate(input, options = {}, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/availability/${this.ctx.tenant}/availability/bulk`,
+      ...options.vendorId === void 0 ? {} : { headers: { "vendor-id": options.vendorId } },
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Bulk-updates availability records (`PUT /availability/bulk`). Responds 207
+   * Multi-Status: partial failures do **not** throw — inspect each entry. See
+   * {@link bulkCreate} for the `vendorId` header caveat. Default auth: service.
+   */
+  async bulkUpdate(input, options = {}, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `/availability/${this.ctx.tenant}/availability/bulk`,
+      ...options.vendorId === void 0 ? {} : { headers: { "vendor-id": options.vendorId } },
+      body: input,
+      auth: auth2
+    });
+  }
+  /**
+   * Bulk-deletes availability records (`DELETE /availability/bulk`). Unusually
+   * for a DELETE, this endpoint takes a body listing the records to remove.
+   * Responds 207 Multi-Status: partial failures do **not** throw — inspect each
+   * entry. See {@link bulkCreate} for the `vendorId` header caveat. Default
+   * auth: service.
+   */
+  async bulkDelete(input, options = {}, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "DELETE",
+      path: `/availability/${this.ctx.tenant}/availability/bulk`,
+      ...options.vendorId === void 0 ? {} : { headers: { "vendor-id": options.vendorId } },
+      body: input,
+      auth: auth2
+    });
+  }
 };
 
 // src/services/tenant-config.ts
-var SERVICE4 = { kind: "service" };
+var SERVICE9 = { kind: "service" };
 var TenantConfigService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -2930,7 +4539,7 @@ var TenantConfigService = class {
     return `/configuration/${this.ctx.tenant}/configurations`;
   }
   /** List tenant configurations, optionally filtered by `keys`. */
-  async list(opts = {}, auth2 = SERVICE4) {
+  async list(opts = {}, auth2 = SERVICE9) {
     const query = opts.keys && opts.keys.length > 0 ? { keys: opts.keys.join(",") } : void 0;
     return this.ctx.http.request({
       method: "GET",
@@ -2940,7 +4549,7 @@ var TenantConfigService = class {
     });
   }
   /** Retrieve one tenant configuration by key. */
-  async get(key, auth2 = SERVICE4) {
+  async get(key, auth2 = SERVICE9) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${encodeURIComponent(key)}`,
@@ -2948,7 +4557,7 @@ var TenantConfigService = class {
     });
   }
   /** Create one or more tenant configurations (array in, array out). */
-  async create(drafts, auth2 = SERVICE4) {
+  async create(drafts, auth2 = SERVICE9) {
     return this.ctx.http.request({
       method: "POST",
       path: this.base(),
@@ -2957,7 +4566,7 @@ var TenantConfigService = class {
     });
   }
   /** Update one tenant configuration by key. */
-  async update(key, draft, auth2 = SERVICE4) {
+  async update(key, draft, auth2 = SERVICE9) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/${encodeURIComponent(key)}`,
@@ -2966,17 +4575,29 @@ var TenantConfigService = class {
     });
   }
   /** Delete one tenant configuration by key. */
-  async delete(key, auth2 = SERVICE4) {
+  async delete(key, auth2 = SERVICE9) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/${encodeURIComponent(key)}`,
       auth: auth2
     });
   }
+  /**
+   * List the platform-wide global configurations
+   * (`GET /global-configurations`) — a separate resource from the tenant's own
+   * `/configurations`.
+   */
+  async listGlobal(auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/configuration/${this.ctx.tenant}/global-configurations`,
+      auth: auth2
+    });
+  }
 };
 
 // src/services/client-config.ts
-var SERVICE5 = { kind: "service" };
+var SERVICE10 = { kind: "service" };
 var ClientConfigService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -2987,7 +4608,7 @@ var ClientConfigService = class {
     return `/configuration/${this.ctx.tenant}/clients/${encodeURIComponent(client)}/configurations`;
   }
   /** List a client's configurations, optionally filtered by `keys`. */
-  async list(client, opts = {}, auth2 = SERVICE5) {
+  async list(client, opts = {}, auth2 = SERVICE10) {
     const query = opts.keys && opts.keys.length > 0 ? { keys: opts.keys.join(",") } : void 0;
     return this.ctx.http.request({
       method: "GET",
@@ -2997,7 +4618,7 @@ var ClientConfigService = class {
     });
   }
   /** Retrieve one client configuration by key. */
-  async get(client, key, auth2 = SERVICE5) {
+  async get(client, key, auth2 = SERVICE10) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base(client)}/${encodeURIComponent(key)}`,
@@ -3005,7 +4626,7 @@ var ClientConfigService = class {
     });
   }
   /** Create one or more client configurations. Injects `client` into each item. */
-  async create(client, drafts, auth2 = SERVICE5) {
+  async create(client, drafts, auth2 = SERVICE10) {
     const body = drafts.map((d) => ({ ...d, client }));
     return this.ctx.http.request({
       method: "POST",
@@ -3015,7 +4636,7 @@ var ClientConfigService = class {
     });
   }
   /** Update one client configuration by key. Injects `client` into the body. */
-  async update(client, key, draft, auth2 = SERVICE5) {
+  async update(client, key, draft, auth2 = SERVICE10) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base(client)}/${encodeURIComponent(key)}`,
@@ -3024,13 +4645,25 @@ var ClientConfigService = class {
     });
   }
   /** Delete one client configuration by key. */
-  async delete(client, key, auth2 = SERVICE5) {
+  async delete(client, key, auth2 = SERVICE10) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base(client)}/${encodeURIComponent(key)}`,
       auth: auth2
     });
   }
+  /**
+   * List the client ids that have configurations (`GET /clients`). Note this
+   * targets `/configuration/{tenant}/clients` directly — the private `base`
+   * helper appends `/configurations` for a specific client.
+   */
+  async listClients(auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/configuration/${this.ctx.tenant}/clients`,
+      auth: auth2
+    });
+  }
 };
 
 // src/services/shopping-list.ts
@@ -3131,7 +4764,7 @@ var ShoppingListService = class {
 };
 
 // src/services/ai-rag-indexer.ts
-var SERVICE6 = { kind: "service" };
+var SERVICE11 = { kind: "service" };
 var RagIndexerService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -3142,7 +4775,7 @@ var RagIndexerService = class {
     return `/ai-rag-indexer/${this.ctx.tenant}/${encodeURIComponent(type)}`;
   }
   /** The indexable embedding field names for `type` (default `"PRODUCT"`). */
-  async ragMetadata(type = "PRODUCT", auth2 = SERVICE6) {
+  async ragMetadata(type = "PRODUCT", auth2 = SERVICE11) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base(type)}/rag-metadata`,
@@ -3150,7 +4783,7 @@ var RagIndexerService = class {
     });
   }
   /** The filterable metadata fields for `type` (default `"PRODUCT"`). */
-  async filterMetadata(type = "PRODUCT", auth2 = SERVICE6) {
+  async filterMetadata(type = "PRODUCT", auth2 = SERVICE11) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base(type)}/filter-metadata`,
@@ -3164,7 +4797,7 @@ var RagIndexerService = class {
    * @deprecated since 2026-06-18, removal 2026-12-01 — use the indexing service:
    * `client.indexing.createReindexJob({ entityType: "PRODUCT", rag: true })`.
    */
-  async reindex(type = "PRODUCT", auth2 = SERVICE6) {
+  async reindex(type = "PRODUCT", auth2 = SERVICE11) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base(type)}/reindex`,
@@ -3174,7 +4807,7 @@ var RagIndexerService = class {
 };
 
 // src/services/sequential-id.ts
-var SERVICE7 = { kind: "service" };
+var SERVICE12 = { kind: "service" };
 var SequentialIdService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -3185,7 +4818,7 @@ var SequentialIdService = class {
     return `/sequential-id/${this.ctx.tenant}/schemas`;
   }
   /** List all sequence schemas for the tenant. */
-  async listSchemas(auth2 = SERVICE7) {
+  async listSchemas(auth2 = SERVICE12) {
     return this.ctx.http.request({
       method: "GET",
       path: this.base(),
@@ -3193,7 +4826,7 @@ var SequentialIdService = class {
     });
   }
   /** Retrieve one sequence schema by id. */
-  async getSchema(schemaId, auth2 = SERVICE7) {
+  async getSchema(schemaId, auth2 = SERVICE12) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${encodeURIComponent(schemaId)}`,
@@ -3201,7 +4834,7 @@ var SequentialIdService = class {
     });
   }
   /** Create a sequence schema. Schemas are immutable — there is no update. */
-  async createSchema(schema, auth2 = SERVICE7) {
+  async createSchema(schema, auth2 = SERVICE12) {
     return this.ctx.http.request({
       method: "POST",
       path: this.base(),
@@ -3210,7 +4843,7 @@ var SequentialIdService = class {
     });
   }
   /** Delete a sequence schema by id. */
-  async deleteSchema(schemaId, auth2 = SERVICE7) {
+  async deleteSchema(schemaId, auth2 = SERVICE12) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/${encodeURIComponent(schemaId)}`,
@@ -3218,7 +4851,7 @@ var SequentialIdService = class {
     });
   }
   /** Mark a schema active for its type (only one schema may be active per type). */
-  async setActiveSchema(schemaId, auth2 = SERVICE7) {
+  async setActiveSchema(schemaId, auth2 = SERVICE12) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/${encodeURIComponent(schemaId)}/setActive`,
@@ -3226,7 +4859,7 @@ var SequentialIdService = class {
     });
   }
   /** Get the active schema for a given schema type. */
-  async listSchemasByType(schemaType, auth2 = SERVICE7) {
+  async listSchemasByType(schemaType, auth2 = SERVICE12) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/types/${encodeURIComponent(schemaType)}`,
@@ -3238,7 +4871,7 @@ var SequentialIdService = class {
    * `sequenceKey` (independent sub-pool counter) and `placeholders`.
    * `opts.siteCode` derives time/country placeholders from the site's settings.
    */
-  async nextId(schemaType, body = {}, opts = {}, auth2 = SERVICE7) {
+  async nextId(schemaType, body = {}, opts = {}, auth2 = SERVICE12) {
     const query = opts.siteCode ? { siteCode: opts.siteCode } : void 0;
     return this.ctx.http.request({
       method: "POST",
@@ -3253,7 +4886,7 @@ var SequentialIdService = class {
    * endpoint path omits the `{tenant}` segment — the service derives the
    * tenant from the token.
    */
-  async nextIdsBatch(req, auth2 = SERVICE7) {
+  async nextIdsBatch(req, auth2 = SERVICE12) {
     return this.ctx.http.request({
       method: "POST",
       path: `/sequential-id/sequenceSchemaBatch/nextIds`,
@@ -3264,7 +4897,7 @@ var SequentialIdService = class {
 };
 
 // src/services/fee.ts
-var SERVICE8 = { kind: "service" };
+var SERVICE13 = { kind: "service" };
 var FeeService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -3287,7 +4920,7 @@ var FeeService = class {
    * returned page is full). Defaults match Emporix server defaults
    * (`pageNumber: 1`, `pageSize: 60`).
    */
-  async list(query = {}, auth2 = SERVICE8) {
+  async list(query = {}, auth2 = SERVICE13) {
     const pageNumber = query.pageNumber ?? 1;
     const pageSize = query.pageSize ?? 60;
     const items = await this.ctx.http.request({
@@ -3299,7 +4932,7 @@ var FeeService = class {
     return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
   }
   /** Retrieve one fee definition by id. */
-  async get(id, auth2 = SERVICE8) {
+  async get(id, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.feesBase()}/${encodeURIComponent(id)}`,
@@ -3307,7 +4940,7 @@ var FeeService = class {
     });
   }
   /** Create a fee definition. */
-  async create(draft, auth2 = SERVICE8) {
+  async create(draft, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "POST",
       path: this.feesBase(),
@@ -3316,7 +4949,7 @@ var FeeService = class {
     });
   }
   /** Update a fee definition by id. */
-  async update(id, draft, auth2 = SERVICE8) {
+  async update(id, draft, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.feesBase()}/${encodeURIComponent(id)}`,
@@ -3325,7 +4958,7 @@ var FeeService = class {
     });
   }
   /** Delete a fee definition by id. */
-  async delete(id, auth2 = SERVICE8) {
+  async delete(id, auth2 = SERVICE13) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.feesBase()}/${encodeURIComponent(id)}`,
@@ -3334,7 +4967,7 @@ var FeeService = class {
   }
   // --- Item-fee mappings ---
   /** List all item-fee mappings. */
-  async listItemFees(auth2 = SERVICE8) {
+  async listItemFees(auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "GET",
       path: this.itemFeesBase(),
@@ -3342,7 +4975,7 @@ var FeeService = class {
     });
   }
   /** Fee mappings for one item YRN. */
-  async getItemFees(itemYrn, auth2 = SERVICE8) {
+  async getItemFees(itemYrn, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.itemFeesBase()}/${encodeURIComponent(itemYrn)}/fees`,
@@ -3350,7 +4983,7 @@ var FeeService = class {
     });
   }
   /** Create an item-fee mapping. */
-  async createItemFee(draft, auth2 = SERVICE8) {
+  async createItemFee(draft, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "POST",
       path: this.itemFeesBase(),
@@ -3362,7 +4995,7 @@ var FeeService = class {
    * Set the fee list for an item YRN. Destructive replace by default; pass
    * `{ partial: true }` to merge (`?partial=true`).
    */
-  async setItemFees(itemYrn, feeIds, opts = {}, auth2 = SERVICE8) {
+  async setItemFees(itemYrn, feeIds, opts = {}, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.itemFeesBase()}/${encodeURIComponent(itemYrn)}/fees`,
@@ -3375,7 +5008,7 @@ var FeeService = class {
    * Delete item-fee mappings for a YRN. Without `feeId`, removes all mappings
    * for the YRN; with `feeId`, removes that single fee from the mapping.
    */
-  async deleteItemFees(itemYrn, feeId, auth2 = SERVICE8) {
+  async deleteItemFees(itemYrn, feeId, auth2 = SERVICE13) {
     const base = `${this.itemFeesBase()}/${encodeURIComponent(itemYrn)}/fees`;
     await this.ctx.http.request({
       method: "DELETE",
@@ -3384,7 +5017,7 @@ var FeeService = class {
     });
   }
   /** Search item-fee mappings by item YRNs + site. */
-  async searchItemFees(search, auth2 = SERVICE8) {
+  async searchItemFees(search, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.itemFeesBase()}/search`,
@@ -3394,7 +5027,7 @@ var FeeService = class {
   }
   // --- Product-fee mappings ---
   /** Fee mappings for a product id. */
-  async getProductFees(productId, auth2 = SERVICE8) {
+  async getProductFees(productId, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.productFeesBase()}/${encodeURIComponent(productId)}/fees`,
@@ -3405,7 +5038,7 @@ var FeeService = class {
    * Set the fee list for a product id. Destructive replace by default; pass
    * `{ partial: true }` to merge (`?partial=true`).
    */
-  async setProductFees(productId, feeIds, opts = {}, auth2 = SERVICE8) {
+  async setProductFees(productId, feeIds, opts = {}, auth2 = SERVICE13) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.productFeesBase()}/${encodeURIComponent(productId)}/fees`,
@@ -3415,13 +5048,54 @@ var FeeService = class {
     });
   }
   /** Delete all fee mappings for a product id. */
-  async deleteProductFees(productId, auth2 = SERVICE8) {
+  async deleteProductFees(productId, auth2 = SERVICE13) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.productFeesBase()}/${encodeURIComponent(productId)}/fees`,
       auth: auth2
     });
   }
+  /**
+   * Removes **one** fee from a product
+   * (`DELETE /productFees/{productId}/fees/{feeId}`). Use
+   * {@link deleteProductFees} to clear every fee of a product.
+   */
+  async deleteProductFee(productId, feeId, auth2 = SERVICE13) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.productFeesBase()}/${encodeURIComponent(productId)}/fees/${encodeURIComponent(feeId)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Finds item fees for one product across several sites
+   * (`POST /itemFees/searchByProductId`).
+   */
+  async searchItemFeesByProductId(search, auth2 = SERVICE13) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.itemFeesBase()}/searchByProductId`,
+      auth: auth2,
+      body: search,
+      idempotent: true
+      // pure read over POST — safe to replay on 5xx/429
+    });
+  }
+  /**
+   * Finds item fees for several products on one site
+   * (`POST /itemFees/searchByProductIds`). Note the upstream asymmetry:
+   * `productIds` is a comma-separated **string** and `siteCode` is singular.
+   */
+  async searchItemFeesByProductIds(search, auth2 = SERVICE13) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.itemFeesBase()}/searchByProductIds`,
+      auth: auth2,
+      body: search,
+      idempotent: true
+      // pure read over POST — safe to replay on 5xx/429
+    });
+  }
 };
 
 // src/services/cloud-functions.ts
@@ -3448,7 +5122,7 @@ var CloudFunctionsService = class {
 };
 
 // src/services/webhook.ts
-var SERVICE9 = { kind: "service" };
+var SERVICE14 = { kind: "service" };
 var WebhookService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -3459,7 +5133,7 @@ var WebhookService = class {
     return `/webhook/${this.ctx.tenant}`;
   }
   /** List the event-subscription catalog with each event's on/off state. */
-  async listEventSubscriptions(auth2 = SERVICE9) {
+  async listEventSubscriptions(auth2 = SERVICE14) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/event-subscriptions`,
@@ -3472,7 +5146,7 @@ var WebhookService = class {
    * `code`/`status` (e.g. `results.filter(r => (r.code ?? 0) >= 400)`). Does
    * NOT throw on a 207 with failed items; only a non-2xx HTTP status throws.
    */
-  async updateEventSubscriptions(items, auth2 = SERVICE9) {
+  async updateEventSubscriptions(items, auth2 = SERVICE14) {
     return this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/event-subscriptions`,
@@ -3481,7 +5155,7 @@ var WebhookService = class {
     });
   }
   /** List delivery configurations. */
-  async listConfigs(auth2 = SERVICE9) {
+  async listConfigs(auth2 = SERVICE14) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/config`,
@@ -3489,7 +5163,7 @@ var WebhookService = class {
     });
   }
   /** Retrieve one delivery configuration by code. */
-  async getConfig(code, auth2 = SERVICE9) {
+  async getConfig(code, auth2 = SERVICE14) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/config/${encodeURIComponent(code)}`,
@@ -3497,7 +5171,7 @@ var WebhookService = class {
     });
   }
   /** Create a delivery configuration. Returns the server-assigned `{ code }`. */
-  async createConfig(draft, auth2 = SERVICE9) {
+  async createConfig(draft, auth2 = SERVICE14) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/config`,
@@ -3506,7 +5180,7 @@ var WebhookService = class {
     });
   }
   /** Replace a delivery configuration by code (204). */
-  async replaceConfig(code, draft, auth2 = SERVICE9) {
+  async replaceConfig(code, draft, auth2 = SERVICE14) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/config/${encodeURIComponent(code)}`,
@@ -3518,7 +5192,7 @@ var WebhookService = class {
    * Partially update a delivery configuration by code (204). The body is an
    * **array** of `{ op, path, value }` operations (UPSERT / REMOVE).
    */
-  async patchConfig(code, patches, auth2 = SERVICE9) {
+  async patchConfig(code, patches, auth2 = SERVICE14) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/config/${encodeURIComponent(code)}`,
@@ -3530,7 +5204,7 @@ var WebhookService = class {
    * Delete a delivery configuration by code. Pass `{ force: true }` to delete
    * the currently-active config (the server otherwise rejects it).
    */
-  async deleteConfig(code, opts = {}, auth2 = SERVICE9) {
+  async deleteConfig(code, opts = {}, auth2 = SERVICE14) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/config/${encodeURIComponent(code)}`,
@@ -3539,7 +5213,7 @@ var WebhookService = class {
     });
   }
   /** Read delivery statistics over an optional `YYYY-MM` range. */
-  async getStatistics(query = {}, auth2 = SERVICE9) {
+  async getStatistics(query = {}, auth2 = SERVICE14) {
     const q = {};
     if (query.fromYearMonth) q.fromYearMonth = query.fromYearMonth;
     if (query.toYearMonth) q.toYearMonth = query.toYearMonth;
@@ -3551,7 +5225,7 @@ var WebhookService = class {
     });
   }
   /** Obtain Svix dashboard access (URL / token). */
-  async getDashboardAccess(auth2 = SERVICE9) {
+  async getDashboardAccess(auth2 = SERVICE14) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/dashboard-access`,
@@ -3561,7 +5235,10 @@ var WebhookService = class {
 };
 
 // src/services/schema.ts
-var SERVICE10 = { kind: "service" };
+var SERVICE15 = { kind: "service" };
+function toJsonBlob(file) {
+  return file instanceof Blob ? file : new Blob([JSON.stringify(file)], { type: "application/json" });
+}
 var SchemaService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -3577,6 +5254,9 @@ var SchemaService = class {
   instancesBase(type) {
     return `${this.entitiesBase()}/${encodeURIComponent(type)}/instances`;
   }
+  referencesBase() {
+    return `/schema/${this.ctx.tenant}/references`;
+  }
   // --- (A) Schemas ---------------------------------------------------------
   /**
    * List schemas, wrapped in the shared {@link PaginatedItems} envelope.
@@ -3584,7 +5264,7 @@ var SchemaService = class {
    * Pagination defaults match the rest of the SDK (`pageNumber: 1`,
    * `pageSize: 60`).
    */
-  async listSchemas(query = {}, auth2 = SERVICE10) {
+  async listSchemas(query = {}, auth2 = SERVICE15) {
     const pageNumber = query.pageNumber ?? 1;
     const pageSize = query.pageSize ?? 60;
     const q = { pageNumber, pageSize };
@@ -3599,7 +5279,7 @@ var SchemaService = class {
     return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
   }
   /** Retrieve one schema by id. */
-  async getSchema(id, auth2 = SERVICE10) {
+  async getSchema(id, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.schemasBase()}/${encodeURIComponent(id)}`,
@@ -3607,7 +5287,7 @@ var SchemaService = class {
     });
   }
   /** Create a schema. */
-  async createSchema(draft, auth2 = SERVICE10) {
+  async createSchema(draft, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "POST",
       path: this.schemasBase(),
@@ -3620,7 +5300,7 @@ var SchemaService = class {
    * stale version yields 409 Conflict (propagated as the standard conflict
    * error).
    */
-  async updateSchema(id, draft, auth2 = SERVICE10) {
+  async updateSchema(id, draft, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.schemasBase()}/${encodeURIComponent(id)}`,
@@ -3629,7 +5309,7 @@ var SchemaService = class {
     });
   }
   /** Delete a schema by id. */
-  async deleteSchema(id, auth2 = SERVICE10) {
+  async deleteSchema(id, auth2 = SERVICE15) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.schemasBase()}/${encodeURIComponent(id)}`,
@@ -3640,7 +5320,7 @@ var SchemaService = class {
    * Validate a schema document without persisting it (`POST /schemas/file`).
    * Returns the server's validation result verbatim.
    */
-  async validateSchemaFile(body, auth2 = SERVICE10) {
+  async validateSchemaFile(body, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.schemasBase()}/file`,
@@ -3650,7 +5330,7 @@ var SchemaService = class {
   }
   // --- (B) Types -----------------------------------------------------------
   /** List entity types that currently have at least one schema. */
-  async listTypes(auth2 = SERVICE10) {
+  async listTypes(auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "GET",
       path: `/schema/${this.ctx.tenant}/types`,
@@ -3658,7 +5338,7 @@ var SchemaService = class {
     });
   }
   /** Set the entity types a schema applies to (`PUT /schemas/{id}/types`). */
-  async setSchemaTypes(id, types, auth2 = SERVICE10) {
+  async setSchemaTypes(id, types, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.schemasBase()}/${encodeURIComponent(id)}/types`,
@@ -3668,7 +5348,7 @@ var SchemaService = class {
   }
   // --- (C) Custom entities -------------------------------------------------
   /** List custom-entity definitions. `expandSchemas` inlines each schema body. */
-  async listCustomEntities(opts = {}, auth2 = SERVICE10) {
+  async listCustomEntities(opts = {}, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "GET",
       path: this.entitiesBase(),
@@ -3677,7 +5357,7 @@ var SchemaService = class {
     });
   }
   /** Retrieve one custom-entity definition by id. */
-  async getCustomEntity(id, auth2 = SERVICE10) {
+  async getCustomEntity(id, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.entitiesBase()}/${encodeURIComponent(id)}`,
@@ -3685,7 +5365,7 @@ var SchemaService = class {
     });
   }
   /** Create a custom-entity definition. */
-  async createCustomEntity(draft, auth2 = SERVICE10) {
+  async createCustomEntity(draft, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "POST",
       path: this.entitiesBase(),
@@ -3694,7 +5374,7 @@ var SchemaService = class {
     });
   }
   /** Update a custom-entity definition. */
-  async updateCustomEntity(id, draft, auth2 = SERVICE10) {
+  async updateCustomEntity(id, draft, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.entitiesBase()}/${encodeURIComponent(id)}`,
@@ -3707,7 +5387,7 @@ var SchemaService = class {
    * instances or schemas still reference it (propagated as the standard
    * conflict error).
    */
-  async deleteCustomEntity(id, auth2 = SERVICE10) {
+  async deleteCustomEntity(id, auth2 = SERVICE15) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.entitiesBase()}/${encodeURIComponent(id)}`,
@@ -3719,7 +5399,7 @@ var SchemaService = class {
    * List a custom entity's instances, wrapped in {@link PaginatedItems}.
    * `type` is the custom-entity type and is always the first argument.
    */
-  async listInstances(type, query = {}, auth2 = SERVICE10) {
+  async listInstances(type, query = {}, auth2 = SERVICE15) {
     const pageNumber = query.pageNumber ?? 1;
     const pageSize = query.pageSize ?? 60;
     const items = await this.ctx.http.request({
@@ -3731,7 +5411,7 @@ var SchemaService = class {
     return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
   }
   /** Retrieve one instance by id. */
-  async getInstance(type, id, auth2 = SERVICE10) {
+  async getInstance(type, id, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
@@ -3739,7 +5419,7 @@ var SchemaService = class {
     });
   }
   /** Create an instance of a custom entity. */
-  async createInstance(type, draft, auth2 = SERVICE10) {
+  async createInstance(type, draft, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "POST",
       path: this.instancesBase(type),
@@ -3748,7 +5428,7 @@ var SchemaService = class {
     });
   }
   /** Replace an instance (full `PUT`). */
-  async replaceInstance(type, id, draft, auth2 = SERVICE10) {
+  async replaceInstance(type, id, draft, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
@@ -3757,7 +5437,7 @@ var SchemaService = class {
     });
   }
   /** Partially update an instance (`PATCH`). */
-  async patchInstance(type, id, patch, auth2 = SERVICE10) {
+  async patchInstance(type, id, patch, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "PATCH",
       path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
@@ -3771,7 +5451,7 @@ var SchemaService = class {
    * a per-item result array — a 207 is success, individual failures live in
    * each item's `code`/`status`.
    */
-  async bulkPatchInstances(type, items, auth2 = SERVICE10) {
+  async bulkPatchInstances(type, items, auth2 = SERVICE15) {
     return this.ctx.http.request({
       method: "PATCH",
       path: `${this.instancesBase(type)}/bulk`,
@@ -3779,8 +5459,80 @@ var SchemaService = class {
       body: items
     });
   }
+  /**
+   * Create multiple instances in one request
+   * (`POST /custom-entities/{type}/instances/bulk`). Returns a 207 envelope:
+   * a per-item result array — a 207 is success, individual failures live in
+   * each item's `code`/`status`.
+   */
+  async bulkCreateInstances(type, items, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.instancesBase(type)}/bulk`,
+      auth: auth2,
+      body: items
+    });
+  }
+  /**
+   * Upsert multiple instances in one request
+   * (`PUT /custom-entities/{type}/instances/bulk`). Each item carries its `id`.
+   * Returns the same 207 per-item envelope as {@link bulkCreateInstances}.
+   */
+  async bulkUpsertInstances(type, items, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.instancesBase(type)}/bulk`,
+      auth: auth2,
+      body: items
+    });
+  }
+  /**
+   * Delete multiple instances by id
+   * (`DELETE /custom-entities/{type}/instances/bulk`). Returns the same 207
+   * per-item envelope as {@link bulkCreateInstances}.
+   *
+   * **Note:** the OpenAPI schema declares no request body for this operation,
+   * but its description mandates one — "The IDs of items should be defined in
+   * the request body as an array of strings" (example
+   * `["firstId", "secondId"]`). The SDK follows the description and sends the
+   * id array. Unverified against the live API.
+   */
+  async bulkDeleteInstances(type, ids, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.instancesBase(type)}/bulk`,
+      auth: auth2,
+      body: ids
+    });
+  }
+  /**
+   * Export custom entities and their schemas
+   * (`POST /custom-entities/export`). Pass the entity types to include; the
+   * result carries a base64 `data` payload plus `exportedAt`.
+   */
+  async exportCustomEntities(types, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.entitiesBase()}/export`,
+      auth: auth2,
+      body: types
+    });
+  }
+  /**
+   * Import custom entities and their schemas
+   * (`POST /custom-entities/import`) from the base64 `data` produced by
+   * {@link exportCustomEntities}.
+   */
+  async importCustomEntities(input, auth2 = SERVICE15) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.entitiesBase()}/import`,
+      auth: auth2,
+      body: input
+    });
+  }
   /** Delete an instance by id. */
-  async deleteInstance(type, id, auth2 = SERVICE10) {
+  async deleteInstance(type, id, auth2 = SERVICE15) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
@@ -3791,7 +5543,7 @@ var SchemaService = class {
    * Structured search over a custom entity's instances
    * (`POST /instances/search`), wrapped in {@link PaginatedItems}.
    */
-  async searchInstances(type, body, auth2 = SERVICE10) {
+  async searchInstances(type, body, auth2 = SERVICE15) {
     const items = await this.ctx.http.request({
       method: "POST",
       path: `${this.instancesBase(type)}/search`,
@@ -3800,10 +5552,84 @@ var SchemaService = class {
     });
     return { items, pageNumber: 1, pageSize: items.length, hasNextPage: false };
   }
+  // --- (E) References ------------------------------------------------------
+  /**
+   * Reference entities (`/references`) — a schema plus an uploaded JSON file.
+   * Create/update are `multipart/form-data` (parts `file` and `body`), like
+   * the media service's blob upload. Default auth: service.
+   */
+  references = {
+    /**
+     * List references, wrapped in {@link PaginatedItems}. Pagination defaults
+     * match the rest of this service (`pageNumber: 1`, `pageSize: 60`).
+     */
+    list: async (query = {}, auth2 = SERVICE15) => {
+      const pageNumber = query.pageNumber ?? 1;
+      const pageSize = query.pageSize ?? 60;
+      const q = { pageNumber, pageSize };
+      if (query.sort) q.sort = query.sort;
+      if (query.q) q.q = query.q;
+      if (query.fields) q.fields = query.fields;
+      if (query.type) q.type = query.type;
+      const items = await this.ctx.http.request({
+        method: "GET",
+        path: this.referencesBase(),
+        auth: auth2,
+        query: q
+      });
+      return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+    },
+    /** Retrieve one reference by id. */
+    get: async (id, auth2 = SERVICE15) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.referencesBase()}/${encodeURIComponent(id)}`,
+      auth: auth2
+    }),
+    /**
+     * Create a reference. `file` is the reference's JSON content — pass a
+     * `Blob` to upload as-is, or a plain object to have it serialized into a
+     * JSON blob. `body` carries the metadata.
+     */
+    create: async (input, auth2 = SERVICE15) => {
+      const fd = new FormData();
+      fd.set("file", toJsonBlob(input.file));
+      fd.set("body", JSON.stringify(input.body));
+      return this.ctx.http.request({
+        method: "POST",
+        path: this.referencesBase(),
+        auth: auth2,
+        body: fd
+      });
+    },
+    /**
+     * Update a reference (multipart, like {@link create}). `options.version`
+     * enables optimistic locking — the server answers 409 on a stale version.
+     */
+    update: async (id, input, options = {}, auth2 = SERVICE15) => {
+      const fd = new FormData();
+      fd.set("file", toJsonBlob(input.file));
+      fd.set("body", JSON.stringify(input.body));
+      await this.ctx.http.request({
+        method: "PUT",
+        path: `${this.referencesBase()}/${encodeURIComponent(id)}`,
+        ...options.version === void 0 ? {} : { query: { version: options.version } },
+        auth: auth2,
+        body: fd
+      });
+    },
+    /** Delete a reference by id. */
+    delete: async (id, auth2 = SERVICE15) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.referencesBase()}/${encodeURIComponent(id)}`,
+        auth: auth2
+      });
+    }
+  };
 };
 
 // src/services/ai-resources.ts
-var SERVICE11 = { kind: "service" };
+var SERVICE16 = { kind: "service" };
 var AgenticCrudResource = class {
   constructor(ctx, path) {
     this.ctx = ctx;
@@ -3815,15 +5641,15 @@ var AgenticCrudResource = class {
     return `${this.path}/${encodeURIComponent(id)}`;
   }
   /** List the collection (`GET {path}`). Optional `q`/paging/sort/fields/expand. */
-  list(query = {}, auth2 = SERVICE11) {
+  list(query = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: this.path, auth: auth2, query: { ...query } });
   }
   /** Structured search (`POST {path}/search`). Body is `{ q? }`. */
-  search(query, auth2 = SERVICE11) {
+  search(query, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "POST", path: `${this.path}/search`, auth: auth2, body: query });
   }
   /** Retrieve one entry by id (`GET {path}/{id}`). */
-  get(id, opts = {}, auth2 = SERVICE11) {
+  get(id, opts = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: this.item(id), auth: auth2, query: { ...opts } });
   }
   /**
@@ -3831,7 +5657,7 @@ var AgenticCrudResource = class {
    * (HTTP 201) and `undefined` on update (HTTP 204). `{ force: true }`
    * cascade-disables dependents.
    */
-  upsert(id, body, opts = {}, auth2 = SERVICE11) {
+  upsert(id, body, opts = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({
       method: "PUT",
       path: this.item(id),
@@ -3844,11 +5670,11 @@ var AgenticCrudResource = class {
    * Partial update with an op array (`PATCH {path}/{id}`, 204). `ops` use the
    * upstream UPPERCASE enum (`ADD | REMOVE | REPLACE`), sent verbatim.
    */
-  async patch(id, ops, auth2 = SERVICE11) {
+  async patch(id, ops, auth2 = SERVICE16) {
     await this.ctx.http.request({ method: "PATCH", path: this.item(id), auth: auth2, body: ops });
   }
   /** Delete by id (`DELETE {path}/{id}`). `{ force: true }` removes even if referenced. */
-  async delete(id, opts = {}, auth2 = SERVICE11) {
+  async delete(id, opts = {}, auth2 = SERVICE16) {
     await this.ctx.http.request({
       method: "DELETE",
       path: this.item(id),
@@ -3865,19 +5691,19 @@ var JobsResource = class {
   ctx;
   base;
   /** List jobs (`GET /jobs`). */
-  list(query = {}, auth2 = SERVICE11) {
+  list(query = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: `${this.base}/jobs`, auth: auth2, query: { ...query } });
   }
   /** Structured job search (`POST /jobs/search`). */
-  search(query, auth2 = SERVICE11) {
+  search(query, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "POST", path: `${this.base}/jobs/search`, auth: auth2, body: query });
   }
   /** Retrieve one job (`GET /jobs/{jobId}`). */
-  get(jobId, auth2 = SERVICE11) {
+  get(jobId, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: `${this.base}/jobs/${encodeURIComponent(jobId)}`, auth: auth2 });
   }
   /** Delete one job (`DELETE /jobs/{jobId}`). */
-  async delete(jobId, auth2 = SERVICE11) {
+  async delete(jobId, auth2 = SERVICE16) {
     await this.ctx.http.request({ method: "DELETE", path: `${this.base}/jobs/${encodeURIComponent(jobId)}`, auth: auth2 });
   }
 };
@@ -3889,11 +5715,11 @@ var TemplatesResource = class {
   ctx;
   path;
   /** List available templates (`GET /agentic/templates`). */
-  list(query = {}, auth2 = SERVICE11) {
+  list(query = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: this.path, auth: auth2, query: { ...query } });
   }
   /** Structured template search (`POST /agentic/templates/search`). */
-  search(query, auth2 = SERVICE11) {
+  search(query, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "POST", path: `${this.path}/search`, auth: auth2, body: query });
   }
   /**
@@ -3901,7 +5727,7 @@ var TemplatesResource = class {
    * (`POST /agentic/templates/{templateId}/agents`, HTTP 201). Returns the
    * created agent's id.
    */
-  clone(templateId, body, auth2 = SERVICE11) {
+  clone(templateId, body, auth2 = SERVICE16) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.path}/${encodeURIComponent(templateId)}/agents`,
@@ -3918,27 +5744,27 @@ var LogsResource = class {
   ctx;
   path;
   /** List request logs (`GET /agentic/logs/requests`). */
-  listRequests(query = {}, auth2 = SERVICE11) {
+  listRequests(query = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: `${this.path}/requests`, auth: auth2, query: { ...query } });
   }
   /** Retrieve one request log (`GET /agentic/logs/requests/{requestId}`). */
-  getRequest(requestId, auth2 = SERVICE11) {
+  getRequest(requestId, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: `${this.path}/requests/${encodeURIComponent(requestId)}`, auth: auth2 });
   }
   /** Structured request-log search (`POST /agentic/logs/requests/search`). */
-  searchRequests(query, auth2 = SERVICE11) {
+  searchRequests(query, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "POST", path: `${this.path}/requests/search`, auth: auth2, body: query });
   }
   /** List session logs (`GET /agentic/logs/sessions`). */
-  listSessions(query = {}, auth2 = SERVICE11) {
+  listSessions(query = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: `${this.path}/sessions`, auth: auth2, query: { ...query } });
   }
   /** Retrieve one session log (`GET /agentic/logs/sessions/{sessionId}`). */
-  getSession(sessionId, auth2 = SERVICE11) {
+  getSession(sessionId, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: `${this.path}/sessions/${encodeURIComponent(sessionId)}`, auth: auth2 });
   }
   /** Structured session-log search (`POST /agentic/logs/sessions/search`). */
-  searchSessions(query, auth2 = SERVICE11) {
+  searchSessions(query, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "POST", path: `${this.path}/sessions/search`, auth: auth2, body: query });
   }
 };
@@ -3950,17 +5776,17 @@ var AnalyticsResource = class {
   ctx;
   path;
   /** Aggregated metrics (`GET /agentic/analytics`); scope with `agentId`. */
-  get(opts = {}, auth2 = SERVICE11) {
+  get(opts = {}, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: this.path, auth: auth2, query: { ...opts } });
   }
   /** Per-agent execution counts (`GET /agentic/analytics/executions`). `agentIds` required. */
-  executions(query, auth2 = SERVICE11) {
+  executions(query, auth2 = SERVICE16) {
     return this.ctx.http.request({ method: "GET", path: `${this.path}/executions`, auth: auth2, query: { ...query } });
   }
 };
 
 // src/services/ai.ts
-var SERVICE12 = { kind: "service" };
+var SERVICE17 = { kind: "service" };
 var AiService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4012,7 +5838,7 @@ var AiService = class {
     return this._analytics ??= new AnalyticsResource(this.ctx, `${this.base()}/agentic/analytics`);
   }
   /** Generate text from a single prompt (`POST /texts`). Honors `maxTokens`. */
-  async generateText(input, auth2 = SERVICE12) {
+  async generateText(input, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/texts`,
@@ -4021,7 +5847,7 @@ var AiService = class {
     });
   }
   /** Run a chat completion over a message list (`POST /completions`). No `maxTokens`. */
-  async complete(input, auth2 = SERVICE12) {
+  async complete(input, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/completions`,
@@ -4030,7 +5856,7 @@ var AiService = class {
     });
   }
   /** List all agentic agents. */
-  async listAgents(auth2 = SERVICE12) {
+  async listAgents(auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/agentic/agents`,
@@ -4038,7 +5864,7 @@ var AiService = class {
     });
   }
   /** Retrieve one agent by id. */
-  async getAgent(id, auth2 = SERVICE12) {
+  async getAgent(id, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
@@ -4046,7 +5872,7 @@ var AiService = class {
     });
   }
   /** Create-or-replace an agent by id (`PUT`). Takes the agent write shape. */
-  async upsertAgent(id, agent, auth2 = SERVICE12) {
+  async upsertAgent(id, agent, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
@@ -4059,7 +5885,7 @@ var AiService = class {
    * UPPERCASE enum (`ADD | REMOVE | REPLACE`) and are sent verbatim — this is
    * NOT RFC-6902 JSON-Patch.
    */
-  async patchAgent(id, ops, auth2 = SERVICE12) {
+  async patchAgent(id, ops, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
@@ -4071,7 +5897,7 @@ var AiService = class {
    * Delete an agent by id. Pass `{ force: true }` to delete an agent that is
    * still referenced elsewhere (`?force=true`).
    */
-  async deleteAgent(id, auth2 = SERVICE12, opts = {}) {
+  async deleteAgent(id, auth2 = SERVICE17, opts = {}) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
@@ -4080,7 +5906,7 @@ var AiService = class {
     });
   }
   /** Server-side agent search (`POST /agentic/agents/search`). */
-  async searchAgents(query, auth2 = SERVICE12) {
+  async searchAgents(query, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/agents/search`,
@@ -4092,7 +5918,7 @@ var AiService = class {
    * Synchronous agent chat (`POST /agentic/chat`). Returns the response
    * ARRAY verbatim (the upstream contract is an array, not a single object).
    */
-  async chat(input, auth2 = SERVICE12) {
+  async chat(input, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/chat`,
@@ -4104,7 +5930,7 @@ var AiService = class {
    * Fire-and-forget agent chat (`POST /agentic/chat-async`, HTTP 201).
    * Returns the job-id ARRAY verbatim.
    */
-  async chatAsync(input, auth2 = SERVICE12) {
+  async chatAsync(input, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/chat-async`,
@@ -4118,7 +5944,7 @@ var AiService = class {
    * stream body as an opaque string, so chunks are raw strings, not parsed
    * objects. Consume with `for await`.
    */
-  async *chatStream(input, opts = {}, auth2 = SERVICE12) {
+  async *chatStream(input, opts = {}, auth2 = SERVICE17) {
     const events = this.ctx.http.requestStream({
       method: "POST",
       path: `${this.base()}/agentic/chat-stream`,
@@ -4129,7 +5955,7 @@ var AiService = class {
     for await (const ev of events) yield ev.data;
   }
   /** List stored agentic conversations (`GET /agentic/conversations`). */
-  async listConversations(auth2 = SERVICE12) {
+  async listConversations(auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/agentic/conversations`,
@@ -4137,7 +5963,7 @@ var AiService = class {
     });
   }
   /** Server-side conversation search (`POST /agentic/conversations/search`). */
-  async searchConversations(query, auth2 = SERVICE12) {
+  async searchConversations(query, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/conversations/search`,
@@ -4147,7 +5973,7 @@ var AiService = class {
   }
   // --- Standalone agentic reads / bulk operations ------------------------
   /** List models available to the tenant, grouped by provider (`GET /agentic/models`). */
-  async listModels(auth2 = SERVICE12) {
+  async listModels(auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/agentic/models`,
@@ -4155,7 +5981,7 @@ var AiService = class {
     });
   }
   /** List commerce events available to agent triggers (`GET /agentic/commerce-events`). */
-  async listCommerceEvents(auth2 = SERVICE12) {
+  async listCommerceEvents(auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/agentic/commerce-events`,
@@ -4168,7 +5994,7 @@ var AiService = class {
    * `sessionId` must be threaded into subsequent chat calls to bind the file.
    * Pass `opts.sessionId` to attach to an existing session.
    */
-  async uploadAttachment(agentId, attachment, opts = {}, auth2 = SERVICE12) {
+  async uploadAttachment(agentId, attachment, opts = {}, auth2 = SERVICE17) {
     const form = new FormData();
     form.append("attachment", attachment);
     return this.ctx.http.request({
@@ -4180,7 +6006,7 @@ var AiService = class {
     });
   }
   /** Export agents + components as a base64/checksum blob (`POST /agentic/agents/export`). */
-  async exportAgents(body, auth2 = SERVICE12) {
+  async exportAgents(body, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/agents/export`,
@@ -4189,7 +6015,7 @@ var AiService = class {
     });
   }
   /** Import previously-exported agents (`POST /agentic/agents/import`). */
-  async importAgents(body, auth2 = SERVICE12) {
+  async importAgents(body, auth2 = SERVICE17) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/agents/import`,
@@ -4200,7 +6026,7 @@ var AiService = class {
 };
 
 // src/services/tax.ts
-var SERVICE13 = { kind: "service" };
+var SERVICE18 = { kind: "service" };
 var TaxService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4211,7 +6037,7 @@ var TaxService = class {
     return `/tax/${this.ctx.tenant}`;
   }
   /** List all per-location tax configurations. */
-  async listTaxConfigs(auth2 = SERVICE13) {
+  async listTaxConfigs(auth2 = SERVICE18) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/taxes`,
@@ -4219,7 +6045,7 @@ var TaxService = class {
     });
   }
   /** Retrieve one tax configuration by its location (country) code. */
-  async getTaxConfig(locationCode, auth2 = SERVICE13) {
+  async getTaxConfig(locationCode, auth2 = SERVICE18) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/taxes/${encodeURIComponent(locationCode)}`,
@@ -4227,7 +6053,7 @@ var TaxService = class {
     });
   }
   /** Create a tax configuration (`POST`). Returns the created `{ locationCode }`. */
-  async createTaxConfig(input, auth2 = SERVICE13) {
+  async createTaxConfig(input, auth2 = SERVICE18) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/taxes`,
@@ -4239,7 +6065,7 @@ var TaxService = class {
    * Update a tax configuration by location code (`PUT`). `metadata.version` is
    * required (optimistic locking — a stale version yields 409).
    */
-  async updateTaxConfig(locationCode, input, auth2 = SERVICE13) {
+  async updateTaxConfig(locationCode, input, auth2 = SERVICE18) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/taxes/${encodeURIComponent(locationCode)}`,
@@ -4248,7 +6074,7 @@ var TaxService = class {
     });
   }
   /** Delete a tax configuration by location code. */
-  async deleteTaxConfig(locationCode, auth2 = SERVICE13) {
+  async deleteTaxConfig(locationCode, auth2 = SERVICE18) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/taxes/${encodeURIComponent(locationCode)}`,
@@ -4259,7 +6085,7 @@ var TaxService = class {
    * Calculate net/gross values for a price (`PUT /taxes/calculation-commands`).
    * Single command in, single result out.
    */
-  async calculateTax(request, auth2 = SERVICE13) {
+  async calculateTax(request, auth2 = SERVICE18) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/taxes/calculation-commands`,
@@ -4270,7 +6096,7 @@ var TaxService = class {
 };
 
 // src/services/coupon.ts
-var SERVICE14 = { kind: "service" };
+var SERVICE19 = { kind: "service" };
 var CouponService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4281,7 +6107,7 @@ var CouponService = class {
     return `/coupon/${this.ctx.tenant}`;
   }
   /** List coupons by criteria. Returns a plain array. */
-  async listCoupons(query = {}, auth2 = SERVICE14) {
+  async listCoupons(query = {}, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/coupons`,
@@ -4290,7 +6116,7 @@ var CouponService = class {
     });
   }
   /** Retrieve one coupon by code. */
-  async getCoupon(code, auth2 = SERVICE14) {
+  async getCoupon(code, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
@@ -4298,7 +6124,7 @@ var CouponService = class {
     });
   }
   /** Create a coupon (`POST`, HTTP 201). Returns the created resource's `{ id?, yrn? }`. */
-  async createCoupon(input, auth2 = SERVICE14) {
+  async createCoupon(input, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/coupons`,
@@ -4307,7 +6133,7 @@ var CouponService = class {
     });
   }
   /** Replace a coupon by code (`PUT`). Resolves once the update is accepted. */
-  async updateCoupon(code, input, auth2 = SERVICE14) {
+  async updateCoupon(code, input, auth2 = SERVICE19) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
@@ -4316,7 +6142,7 @@ var CouponService = class {
     });
   }
   /** Partially update a coupon by code (`PATCH` merge body). */
-  async patchCoupon(code, patch, auth2 = SERVICE14) {
+  async patchCoupon(code, patch, auth2 = SERVICE19) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
@@ -4325,7 +6151,7 @@ var CouponService = class {
     });
   }
   /** Delete a coupon by code. */
-  async deleteCoupon(code, auth2 = SERVICE14) {
+  async deleteCoupon(code, auth2 = SERVICE19) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
@@ -4336,7 +6162,7 @@ var CouponService = class {
    * Check whether a coupon can be redeemed (`POST /validation`). Resolves when
    * redeemable; throws an `EmporixError` otherwise (no response body).
    */
-  async validateCoupon(code, redemption, auth2 = SERVICE14) {
+  async validateCoupon(code, redemption, auth2 = SERVICE19) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}/validation`,
@@ -4345,7 +6171,7 @@ var CouponService = class {
     });
   }
   /** List a coupon's redemptions by criteria. */
-  async listRedemptions(code, query = {}, auth2 = SERVICE14) {
+  async listRedemptions(code, query = {}, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions`,
@@ -4354,7 +6180,7 @@ var CouponService = class {
     });
   }
   /** Redeem a coupon by creating a redemption (`POST`, HTTP 201). Returns the resource location. */
-  async redeemCoupon(code, redemption, auth2 = SERVICE14) {
+  async redeemCoupon(code, redemption, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions`,
@@ -4363,7 +6189,7 @@ var CouponService = class {
     });
   }
   /** Retrieve one redemption by id. */
-  async getRedemption(code, id, auth2 = SERVICE14) {
+  async getRedemption(code, id, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions/${encodeURIComponent(id)}`,
@@ -4371,7 +6197,7 @@ var CouponService = class {
     });
   }
   /** Delete a redemption by id. */
-  async deleteRedemption(code, id, auth2 = SERVICE14) {
+  async deleteRedemption(code, id, auth2 = SERVICE19) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions/${encodeURIComponent(id)}`,
@@ -4379,7 +6205,7 @@ var CouponService = class {
     });
   }
   /** Retrieve a customer's referral coupon (resolves to an empty body when none exists). */
-  async getReferralCoupon(customerNumber, auth2 = SERVICE14) {
+  async getReferralCoupon(customerNumber, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/referral-coupons/${encodeURIComponent(customerNumber)}`,
@@ -4387,7 +6213,7 @@ var CouponService = class {
     });
   }
   /** Create a referral coupon code for a customer (no request body). */
-  async createReferralCoupon(customerNumber, auth2 = SERVICE14) {
+  async createReferralCoupon(customerNumber, auth2 = SERVICE19) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/referral-coupons/${encodeURIComponent(customerNumber)}`,
@@ -4397,7 +6223,7 @@ var CouponService = class {
 };
 
 // src/services/reward-points.ts
-var SERVICE15 = { kind: "service" };
+var SERVICE20 = { kind: "service" };
 var RewardPointsService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4414,7 +6240,7 @@ var RewardPointsService = class {
   }
   // --- Admin: customer points management (service token) ---
   /** Batch summary across all customers. */
-  async listAllSummaries(query = {}, auth2 = SERVICE15) {
+  async listAllSummaries(query = {}, auth2 = SERVICE20) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/summaryBatch`,
@@ -4423,7 +6249,7 @@ var RewardPointsService = class {
     });
   }
   /** Retrieve one customer's reward-points balance. */
-  async getCustomerPoints(customerId, auth2 = SERVICE15) {
+  async getCustomerPoints(customerId, auth2 = SERVICE20) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/customer/${encodeURIComponent(customerId)}`,
@@ -4431,7 +6257,7 @@ var RewardPointsService = class {
     });
   }
   /** Create a reward-points entry for a customer. */
-  async createCustomerPoints(customerId, input, auth2 = SERVICE15) {
+  async createCustomerPoints(customerId, input, auth2 = SERVICE20) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/customer/${encodeURIComponent(customerId)}`,
@@ -4440,7 +6266,7 @@ var RewardPointsService = class {
     });
   }
   /** Delete a customer's reward points. */
-  async deleteCustomerPoints(customerId, auth2 = SERVICE15) {
+  async deleteCustomerPoints(customerId, auth2 = SERVICE20) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/customer/${encodeURIComponent(customerId)}`,
@@ -4448,7 +6274,7 @@ var RewardPointsService = class {
     });
   }
   /** Retrieve a reward-points summary for one customer. */
-  async getCustomerSummary(customerId, auth2 = SERVICE15) {
+  async getCustomerSummary(customerId, auth2 = SERVICE20) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/customer/${encodeURIComponent(customerId)}/summary`,
@@ -4456,7 +6282,7 @@ var RewardPointsService = class {
     });
   }
   /** Add reward points for a customer. */
-  async addPoints(customerId, input, auth2 = SERVICE15) {
+  async addPoints(customerId, input, auth2 = SERVICE20) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/customer/${encodeURIComponent(customerId)}/addPoints`,
@@ -4465,7 +6291,7 @@ var RewardPointsService = class {
     });
   }
   /** Redeem a customer's reward points (on behalf). */
-  async redeemPoints(customerId, input, auth2 = SERVICE15) {
+  async redeemPoints(customerId, input, auth2 = SERVICE20) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/customer/${encodeURIComponent(customerId)}/redeemPoints`,
@@ -4516,7 +6342,7 @@ var RewardPointsService = class {
   }
   // --- Redeem options (tenant-scoped; read open to customer, management service-only) ---
   /** List redeem options. Defaults to the service token; pass a customer `auth` for storefront reads. */
-  async listRedeemOptions(auth2 = SERVICE15) {
+  async listRedeemOptions(auth2 = SERVICE20) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.tenantBase()}/redeemOptions`,
@@ -4524,7 +6350,7 @@ var RewardPointsService = class {
     });
   }
   /** Create a redeem option. Returns the updated options list. */
-  async createRedeemOption(input, auth2 = SERVICE15) {
+  async createRedeemOption(input, auth2 = SERVICE20) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.tenantBase()}/redeemOptions`,
@@ -4533,7 +6359,7 @@ var RewardPointsService = class {
     });
   }
   /** Update a redeem option by id. Resolves once accepted (no response body). */
-  async updateRedeemOption(redeemOptionId, input, auth2 = SERVICE15) {
+  async updateRedeemOption(redeemOptionId, input, auth2 = SERVICE20) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.tenantBase()}/redeemOptions/${encodeURIComponent(redeemOptionId)}`,
@@ -4542,7 +6368,7 @@ var RewardPointsService = class {
     });
   }
   /** Delete a redeem option by id. */
-  async deleteRedeemOption(redeemOptionId, auth2 = SERVICE15) {
+  async deleteRedeemOption(redeemOptionId, auth2 = SERVICE20) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.tenantBase()}/redeemOptions/${encodeURIComponent(redeemOptionId)}`,
@@ -4552,7 +6378,7 @@ var RewardPointsService = class {
 };
 
 // src/services/brand.ts
-var SERVICE16 = { kind: "service" };
+var SERVICE21 = { kind: "service" };
 var BrandService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4563,7 +6389,7 @@ var BrandService = class {
     return `/brand/brands`;
   }
   /** List all brands. */
-  async listBrands(query = {}, auth2 = SERVICE16) {
+  async listBrands(query = {}, auth2 = SERVICE21) {
     return this.ctx.http.request({
       method: "GET",
       path: this.base(),
@@ -4572,7 +6398,7 @@ var BrandService = class {
     });
   }
   /** Retrieve one brand by id. */
-  async getBrand(brandId, auth2 = SERVICE16) {
+  async getBrand(brandId, auth2 = SERVICE21) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${encodeURIComponent(brandId)}`,
@@ -4580,7 +6406,7 @@ var BrandService = class {
     });
   }
   /** Create a brand. */
-  async createBrand(input, auth2 = SERVICE16) {
+  async createBrand(input, auth2 = SERVICE21) {
     return this.ctx.http.request({
       method: "POST",
       path: this.base(),
@@ -4589,7 +6415,7 @@ var BrandService = class {
     });
   }
   /** Replace a brand by id. */
-  async updateBrand(brandId, input, auth2 = SERVICE16) {
+  async updateBrand(brandId, input, auth2 = SERVICE21) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/${encodeURIComponent(brandId)}`,
@@ -4598,7 +6424,7 @@ var BrandService = class {
     });
   }
   /** Partially update a brand by id. */
-  async patchBrand(brandId, patch, auth2 = SERVICE16) {
+  async patchBrand(brandId, patch, auth2 = SERVICE21) {
     return this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/${encodeURIComponent(brandId)}`,
@@ -4607,7 +6433,7 @@ var BrandService = class {
     });
   }
   /** Delete a brand by id. */
-  async deleteBrand(brandId, auth2 = SERVICE16) {
+  async deleteBrand(brandId, auth2 = SERVICE21) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/${encodeURIComponent(brandId)}`,
@@ -4617,7 +6443,7 @@ var BrandService = class {
 };
 
 // src/services/label.ts
-var SERVICE17 = { kind: "service" };
+var SERVICE22 = { kind: "service" };
 var LabelService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4628,7 +6454,7 @@ var LabelService = class {
     return `/label/labels`;
   }
   /** List all labels. */
-  async listLabels(query = {}, auth2 = SERVICE17) {
+  async listLabels(query = {}, auth2 = SERVICE22) {
     return this.ctx.http.request({
       method: "GET",
       path: this.base(),
@@ -4637,7 +6463,7 @@ var LabelService = class {
     });
   }
   /** Retrieve one label by id. */
-  async getLabel(labelId, auth2 = SERVICE17) {
+  async getLabel(labelId, auth2 = SERVICE22) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${encodeURIComponent(labelId)}`,
@@ -4645,7 +6471,7 @@ var LabelService = class {
     });
   }
   /** Create a label. */
-  async createLabel(input, auth2 = SERVICE17) {
+  async createLabel(input, auth2 = SERVICE22) {
     return this.ctx.http.request({
       method: "POST",
       path: this.base(),
@@ -4654,7 +6480,7 @@ var LabelService = class {
     });
   }
   /** Replace a label by id. */
-  async updateLabel(labelId, input, auth2 = SERVICE17) {
+  async updateLabel(labelId, input, auth2 = SERVICE22) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/${encodeURIComponent(labelId)}`,
@@ -4663,7 +6489,7 @@ var LabelService = class {
     });
   }
   /** Partially update a label by id. */
-  async patchLabel(labelId, patch, auth2 = SERVICE17) {
+  async patchLabel(labelId, patch, auth2 = SERVICE22) {
     return this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/${encodeURIComponent(labelId)}`,
@@ -4672,7 +6498,7 @@ var LabelService = class {
     });
   }
   /** Delete a label by id. */
-  async deleteLabel(labelId, auth2 = SERVICE17) {
+  async deleteLabel(labelId, auth2 = SERVICE22) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/${encodeURIComponent(labelId)}`,
@@ -4682,7 +6508,7 @@ var LabelService = class {
 };
 
 // src/services/country.ts
-var SERVICE18 = { kind: "service" };
+var SERVICE23 = { kind: "service" };
 var CountryService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4693,7 +6519,7 @@ var CountryService = class {
     return `/country/${this.ctx.tenant}`;
   }
   /** List all countries. */
-  async listCountries(query = {}, auth2 = SERVICE18) {
+  async listCountries(query = {}, auth2 = SERVICE23) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/countries`,
@@ -4702,7 +6528,7 @@ var CountryService = class {
     });
   }
   /** Retrieve one country by code. */
-  async getCountry(countryCode, auth2 = SERVICE18) {
+  async getCountry(countryCode, auth2 = SERVICE23) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/countries/${encodeURIComponent(countryCode)}`,
@@ -4710,7 +6536,7 @@ var CountryService = class {
     });
   }
   /** Partially update a country by code. Resolves once accepted (no response body). */
-  async patchCountry(countryCode, patch, auth2 = SERVICE18) {
+  async patchCountry(countryCode, patch, auth2 = SERVICE23) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/countries/${encodeURIComponent(countryCode)}`,
@@ -4719,7 +6545,7 @@ var CountryService = class {
     });
   }
   /** List all regions. */
-  async listRegions(query = {}, auth2 = SERVICE18) {
+  async listRegions(query = {}, auth2 = SERVICE23) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/regions`,
@@ -4728,7 +6554,7 @@ var CountryService = class {
     });
   }
   /** Retrieve one region by code. */
-  async getRegion(regionCode, auth2 = SERVICE18) {
+  async getRegion(regionCode, auth2 = SERVICE23) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/regions/${encodeURIComponent(regionCode)}`,
@@ -4738,7 +6564,7 @@ var CountryService = class {
 };
 
 // src/services/currency.ts
-var SERVICE19 = { kind: "service" };
+var SERVICE24 = { kind: "service" };
 var CurrencyService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4750,7 +6576,7 @@ var CurrencyService = class {
   }
   // --- Currencies ---
   /** List all currencies. */
-  async listCurrencies(query = {}, auth2 = SERVICE19) {
+  async listCurrencies(query = {}, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/currencies`,
@@ -4759,7 +6585,7 @@ var CurrencyService = class {
     });
   }
   /** Retrieve one currency by code. */
-  async getCurrency(code, auth2 = SERVICE19) {
+  async getCurrency(code, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/currencies/${encodeURIComponent(code)}`,
@@ -4767,7 +6593,7 @@ var CurrencyService = class {
     });
   }
   /** Create a currency. */
-  async createCurrency(input, auth2 = SERVICE19) {
+  async createCurrency(input, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/currencies`,
@@ -4776,7 +6602,7 @@ var CurrencyService = class {
     });
   }
   /** Update a currency by code. */
-  async updateCurrency(code, input, auth2 = SERVICE19) {
+  async updateCurrency(code, input, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/currencies/${encodeURIComponent(code)}`,
@@ -4785,7 +6611,7 @@ var CurrencyService = class {
     });
   }
   /** Delete a currency by code. */
-  async deleteCurrency(code, auth2 = SERVICE19) {
+  async deleteCurrency(code, auth2 = SERVICE24) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/currencies/${encodeURIComponent(code)}`,
@@ -4794,7 +6620,7 @@ var CurrencyService = class {
   }
   // --- Exchange rates ---
   /** List all exchange rates. */
-  async listExchangeRates(query = {}, auth2 = SERVICE19) {
+  async listExchangeRates(query = {}, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/exchanges`,
@@ -4803,7 +6629,7 @@ var CurrencyService = class {
     });
   }
   /** Retrieve one exchange rate by code. */
-  async getExchangeRate(code, auth2 = SERVICE19) {
+  async getExchangeRate(code, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/exchanges/${encodeURIComponent(code)}`,
@@ -4811,7 +6637,7 @@ var CurrencyService = class {
     });
   }
   /** Create an exchange rate. */
-  async createExchangeRate(input, auth2 = SERVICE19) {
+  async createExchangeRate(input, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/exchanges`,
@@ -4820,7 +6646,7 @@ var CurrencyService = class {
     });
   }
   /** Update an exchange rate by code. */
-  async updateExchangeRate(code, input, auth2 = SERVICE19) {
+  async updateExchangeRate(code, input, auth2 = SERVICE24) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/exchanges/${encodeURIComponent(code)}`,
@@ -4829,7 +6655,7 @@ var CurrencyService = class {
     });
   }
   /** Delete an exchange rate by code. */
-  async deleteExchangeRate(code, auth2 = SERVICE19) {
+  async deleteExchangeRate(code, auth2 = SERVICE24) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/exchanges/${encodeURIComponent(code)}`,
@@ -4839,7 +6665,7 @@ var CurrencyService = class {
 };
 
 // src/services/shipping.ts
-var SERVICE20 = { kind: "service" };
+var SERVICE25 = { kind: "service" };
 var ShippingService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -4854,7 +6680,7 @@ var ShippingService = class {
   }
   // --- Sites ---
   /** Find shipping-related sites by postal code (`POST /findSite`). */
-  async findSites(input, auth2 = SERVICE20) {
+  async findSites(input, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/findSite`,
@@ -4864,7 +6690,7 @@ var ShippingService = class {
   }
   // --- Zones ---
   /** List shipping zones for a site. */
-  async listZones(site, query = {}, auth2 = SERVICE20) {
+  async listZones(site, query = {}, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/zones`,
@@ -4873,7 +6699,7 @@ var ShippingService = class {
     });
   }
   /** Retrieve one shipping zone. */
-  async getZone(site, zoneId, auth2 = SERVICE20) {
+  async getZone(site, zoneId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
@@ -4881,7 +6707,7 @@ var ShippingService = class {
     });
   }
   /** Create a shipping zone. */
-  async createZone(site, zone, auth2 = SERVICE20) {
+  async createZone(site, zone, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.siteBase(site)}/zones`,
@@ -4890,7 +6716,7 @@ var ShippingService = class {
     });
   }
   /** Replace a shipping zone. */
-  async updateZone(site, zoneId, zone, auth2 = SERVICE20) {
+  async updateZone(site, zoneId, zone, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
@@ -4899,7 +6725,7 @@ var ShippingService = class {
     });
   }
   /** Partially update a shipping zone. */
-  async patchZone(site, zoneId, patch, auth2 = SERVICE20) {
+  async patchZone(site, zoneId, patch, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
@@ -4908,7 +6734,7 @@ var ShippingService = class {
     });
   }
   /** Delete a shipping zone. */
-  async deleteZone(site, zoneId, auth2 = SERVICE20) {
+  async deleteZone(site, zoneId, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
@@ -4917,7 +6743,7 @@ var ShippingService = class {
   }
   // --- Methods (per zone) ---
   /** List shipping methods of a zone. */
-  async listMethods(site, zoneId, query = {}, auth2 = SERVICE20) {
+  async listMethods(site, zoneId, query = {}, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods`,
@@ -4926,7 +6752,7 @@ var ShippingService = class {
     });
   }
   /** Retrieve one shipping method. */
-  async getMethod(site, zoneId, methodId, auth2 = SERVICE20) {
+  async getMethod(site, zoneId, methodId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
@@ -4934,7 +6760,7 @@ var ShippingService = class {
     });
   }
   /** Create a shipping method in a zone. */
-  async createMethod(site, zoneId, method, auth2 = SERVICE20) {
+  async createMethod(site, zoneId, method, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods`,
@@ -4943,7 +6769,7 @@ var ShippingService = class {
     });
   }
   /** Replace a shipping method. */
-  async updateMethod(site, zoneId, methodId, method, auth2 = SERVICE20) {
+  async updateMethod(site, zoneId, methodId, method, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
@@ -4952,7 +6778,7 @@ var ShippingService = class {
     });
   }
   /** Partially update a shipping method. */
-  async patchMethod(site, zoneId, methodId, patch, auth2 = SERVICE20) {
+  async patchMethod(site, zoneId, methodId, patch, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
@@ -4961,7 +6787,7 @@ var ShippingService = class {
     });
   }
   /** Delete a shipping method. */
-  async deleteMethod(site, zoneId, methodId, auth2 = SERVICE20) {
+  async deleteMethod(site, zoneId, methodId, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
@@ -4970,7 +6796,7 @@ var ShippingService = class {
   }
   // --- Cost / quote ---
   /** Calculate the final shipping cost (`POST /quote`). */
-  async quote(site, input, auth2 = SERVICE20) {
+  async quote(site, input, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.siteBase(site)}/quote`,
@@ -4979,7 +6805,7 @@ var ShippingService = class {
     });
   }
   /** Calculate the minimum shipping cost (`POST /quote/minimum`). */
-  async quoteMinimum(site, input, auth2 = SERVICE20) {
+  async quoteMinimum(site, input, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.siteBase(site)}/quote/minimum`,
@@ -4988,7 +6814,7 @@ var ShippingService = class {
     });
   }
   /** Calculate the shipping cost for a given slot (`POST /quote/slot`). */
-  async quoteSlot(site, input, auth2 = SERVICE20) {
+  async quoteSlot(site, input, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.siteBase(site)}/quote/slot`,
@@ -4998,7 +6824,7 @@ var ShippingService = class {
   }
   // --- Groups ---
   /** List shipping groups for a site. */
-  async listGroups(site, query = {}, auth2 = SERVICE20) {
+  async listGroups(site, query = {}, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/groups`,
@@ -5007,7 +6833,7 @@ var ShippingService = class {
     });
   }
   /** Retrieve one shipping group. */
-  async getGroup(site, groupId, auth2 = SERVICE20) {
+  async getGroup(site, groupId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/groups/${encodeURIComponent(groupId)}`,
@@ -5015,7 +6841,7 @@ var ShippingService = class {
     });
   }
   /** Create a shipping group. */
-  async createGroup(site, group, auth2 = SERVICE20) {
+  async createGroup(site, group, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.siteBase(site)}/groups`,
@@ -5024,7 +6850,7 @@ var ShippingService = class {
     });
   }
   /** Replace a shipping group. */
-  async updateGroup(site, groupId, group, auth2 = SERVICE20) {
+  async updateGroup(site, groupId, group, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.siteBase(site)}/groups/${encodeURIComponent(groupId)}`,
@@ -5033,7 +6859,7 @@ var ShippingService = class {
     });
   }
   /** Delete a shipping group. */
-  async deleteGroup(site, groupId, auth2 = SERVICE20) {
+  async deleteGroup(site, groupId, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.siteBase(site)}/groups/${encodeURIComponent(groupId)}`,
@@ -5042,7 +6868,7 @@ var ShippingService = class {
   }
   // --- Customer-group relations ---
   /** List customer-group relations for a site. */
-  async listCgRelations(site, query = {}, auth2 = SERVICE20) {
+  async listCgRelations(site, query = {}, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/cgrelations`,
@@ -5051,7 +6877,7 @@ var ShippingService = class {
     });
   }
   /** Retrieve a customer's customer-group relations. */
-  async getCgRelations(site, customerId, auth2 = SERVICE20) {
+  async getCgRelations(site, customerId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.siteBase(site)}/cgrelations/${encodeURIComponent(customerId)}`,
@@ -5059,7 +6885,7 @@ var ShippingService = class {
     });
   }
   /** Create a customer-group relation. */
-  async createCgRelation(site, relation, auth2 = SERVICE20) {
+  async createCgRelation(site, relation, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.siteBase(site)}/cgrelations`,
@@ -5068,7 +6894,7 @@ var ShippingService = class {
     });
   }
   /** Update a customer's customer-group relations. */
-  async updateCgRelations(site, customerId, relation, auth2 = SERVICE20) {
+  async updateCgRelations(site, customerId, relation, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.siteBase(site)}/cgrelations/${encodeURIComponent(customerId)}`,
@@ -5077,7 +6903,7 @@ var ShippingService = class {
     });
   }
   /** Delete a customer's customer-group relation. */
-  async deleteCgRelation(site, customerId, auth2 = SERVICE20) {
+  async deleteCgRelation(site, customerId, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.siteBase(site)}/cgrelations/${encodeURIComponent(customerId)}`,
@@ -5086,7 +6912,7 @@ var ShippingService = class {
   }
   // --- Phase 2: delivery windows ---
   /** Retrieve delivery windows for a delivery area + cart. */
-  async getAreaDeliveryWindows(deliveryAreaId, cartId, auth2 = SERVICE20) {
+  async getAreaDeliveryWindows(deliveryAreaId, cartId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/areaDeliveryTimes/${encodeURIComponent(deliveryAreaId)}/${encodeURIComponent(cartId)}`,
@@ -5094,7 +6920,7 @@ var ShippingService = class {
     });
   }
   /** Retrieve delivery windows for a cart. */
-  async getCartDeliveryWindows(cartId, auth2 = SERVICE20) {
+  async getCartDeliveryWindows(cartId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/actualDeliveryWindows/${encodeURIComponent(cartId)}`,
@@ -5102,7 +6928,7 @@ var ShippingService = class {
     });
   }
   /** Increment the delivery-window counter. */
-  async incrementDeliveryWindowCounter(input, auth2 = SERVICE20) {
+  async incrementDeliveryWindowCounter(input, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/actualDeliveryWindows/incrementCounter`,
@@ -5111,7 +6937,7 @@ var ShippingService = class {
     });
   }
   /** Validate a delivery window. Resolves when valid; throws otherwise. */
-  async validateDeliveryWindow(input, auth2 = SERVICE20) {
+  async validateDeliveryWindow(input, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/deliveryWindowValidation`,
@@ -5121,7 +6947,7 @@ var ShippingService = class {
   }
   // --- Phase 2: delivery times ---
   /** List all delivery times. */
-  async listDeliveryTimes(query = {}, auth2 = SERVICE20) {
+  async listDeliveryTimes(query = {}, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/delivery-times`,
@@ -5130,7 +6956,7 @@ var ShippingService = class {
     });
   }
   /** Retrieve one delivery time. */
-  async getDeliveryTime(deliveryTimeId, auth2 = SERVICE20) {
+  async getDeliveryTime(deliveryTimeId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
@@ -5138,7 +6964,7 @@ var ShippingService = class {
     });
   }
   /** Create a delivery time. */
-  async createDeliveryTime(input, auth2 = SERVICE20) {
+  async createDeliveryTime(input, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/delivery-times`,
@@ -5147,7 +6973,7 @@ var ShippingService = class {
     });
   }
   /** Create multiple delivery times (`POST /delivery-times/bulk`). */
-  async createDeliveryTimesBulk(inputs, auth2 = SERVICE20) {
+  async createDeliveryTimesBulk(inputs, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/delivery-times/bulk`,
@@ -5156,7 +6982,7 @@ var ShippingService = class {
     });
   }
   /** Replace a delivery time. */
-  async updateDeliveryTime(deliveryTimeId, input, auth2 = SERVICE20) {
+  async updateDeliveryTime(deliveryTimeId, input, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
@@ -5165,7 +6991,7 @@ var ShippingService = class {
     });
   }
   /** Partially update a delivery time (JSON-Patch op array). */
-  async patchDeliveryTime(deliveryTimeId, ops, auth2 = SERVICE20) {
+  async patchDeliveryTime(deliveryTimeId, ops, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
@@ -5174,7 +7000,7 @@ var ShippingService = class {
     });
   }
   /** Delete a delivery time. */
-  async deleteDeliveryTime(deliveryTimeId, auth2 = SERVICE20) {
+  async deleteDeliveryTime(deliveryTimeId, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
@@ -5183,7 +7009,7 @@ var ShippingService = class {
   }
   // --- Phase 2: delivery time slots ---
   /** List slots of a delivery time. */
-  async listSlots(deliveryTimeId, auth2 = SERVICE20) {
+  async listSlots(deliveryTimeId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots`,
@@ -5191,7 +7017,7 @@ var ShippingService = class {
     });
   }
   /** Retrieve one slot. */
-  async getSlot(deliveryTimeId, slotId, auth2 = SERVICE20) {
+  async getSlot(deliveryTimeId, slotId, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
@@ -5199,7 +7025,7 @@ var ShippingService = class {
     });
   }
   /** Create a slot in a delivery time. */
-  async createSlot(deliveryTimeId, input, auth2 = SERVICE20) {
+  async createSlot(deliveryTimeId, input, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots`,
@@ -5208,7 +7034,7 @@ var ShippingService = class {
     });
   }
   /** Replace a slot. */
-  async updateSlot(deliveryTimeId, slotId, input, auth2 = SERVICE20) {
+  async updateSlot(deliveryTimeId, slotId, input, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
@@ -5217,7 +7043,7 @@ var ShippingService = class {
     });
   }
   /** Partially update a slot (JSON-Patch op array). */
-  async patchSlot(deliveryTimeId, slotId, ops, auth2 = SERVICE20) {
+  async patchSlot(deliveryTimeId, slotId, ops, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
@@ -5226,7 +7052,7 @@ var ShippingService = class {
     });
   }
   /** Delete a slot. */
-  async deleteSlot(deliveryTimeId, slotId, auth2 = SERVICE20) {
+  async deleteSlot(deliveryTimeId, slotId, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
@@ -5234,7 +7060,7 @@ var ShippingService = class {
     });
   }
   /** Delete all slots of a delivery time. */
-  async deleteAllSlots(deliveryTimeId, auth2 = SERVICE20) {
+  async deleteAllSlots(deliveryTimeId, auth2 = SERVICE25) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots`,
@@ -5243,7 +7069,7 @@ var ShippingService = class {
   }
   // --- Phase 2: delivery cycles ---
   /** Generate a delivery cycle (`POST /delivery-cycles/generate`). Returns the cycle id. */
-  async generateDeliveryCycle(input, auth2 = SERVICE20) {
+  async generateDeliveryCycle(input, auth2 = SERVICE25) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/delivery-cycles/generate`,
@@ -5254,7 +7080,7 @@ var ShippingService = class {
 };
 
 // src/services/invoice.ts
-var SERVICE21 = { kind: "service" };
+var SERVICE26 = { kind: "service" };
 var InvoiceService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5265,7 +7091,7 @@ var InvoiceService = class {
     return `/invoice/${this.ctx.tenant}/jobs/invoices`;
   }
   /** Create an invoice-generation job (`POST …/jobs/invoices`, 201). */
-  async createJob(draft, auth2 = SERVICE21) {
+  async createJob(draft, auth2 = SERVICE26) {
     return this.ctx.http.request({
       method: "POST",
       path: this.base(),
@@ -5274,7 +7100,7 @@ var InvoiceService = class {
     });
   }
   /** Retrieve a job and its per-order results (`GET …/jobs/invoices/{jobId}`). */
-  async getJob(jobId, auth2 = SERVICE21) {
+  async getJob(jobId, auth2 = SERVICE26) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${encodeURIComponent(jobId)}`,
@@ -5429,7 +7255,7 @@ var QuoteReasonsResource = class {
 };
 
 // src/services/returns.ts
-var SERVICE22 = { kind: "service" };
+var SERVICE27 = { kind: "service" };
 var ReturnsService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5440,7 +7266,7 @@ var ReturnsService = class {
     return `/return/${this.ctx.tenant}/returns`;
   }
   /** List returns (paged; supports `pageSize`/`pageNumber`/`sort`/`q`). */
-  async listReturns(query = {}, auth2 = SERVICE22) {
+  async listReturns(query = {}, auth2 = SERVICE27) {
     return this.ctx.http.request({
       method: "GET",
       path: this.base(),
@@ -5449,7 +7275,7 @@ var ReturnsService = class {
     });
   }
   /** Retrieve one return by id. */
-  async getReturn(returnId, auth2 = SERVICE22) {
+  async getReturn(returnId, auth2 = SERVICE27) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${encodeURIComponent(returnId)}`,
@@ -5457,7 +7283,7 @@ var ReturnsService = class {
     });
   }
   /** Create a return. Returns the created `{ id }`. */
-  async createReturn(input, auth2 = SERVICE22) {
+  async createReturn(input, auth2 = SERVICE27) {
     return this.ctx.http.request({
       method: "POST",
       path: this.base(),
@@ -5466,7 +7292,7 @@ var ReturnsService = class {
     });
   }
   /** Replace a return by id (`PUT`). */
-  async updateReturn(returnId, input, auth2 = SERVICE22) {
+  async updateReturn(returnId, input, auth2 = SERVICE27) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/${encodeURIComponent(returnId)}`,
@@ -5475,7 +7301,7 @@ var ReturnsService = class {
     });
   }
   /** Partially update a return by id (`PATCH`, JSON-Patch op-array). */
-  async patchReturn(returnId, ops, auth2 = SERVICE22) {
+  async patchReturn(returnId, ops, auth2 = SERVICE27) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/${encodeURIComponent(returnId)}`,
@@ -5484,7 +7310,7 @@ var ReturnsService = class {
     });
   }
   /** Delete a return by id. */
-  async deleteReturn(returnId, auth2 = SERVICE22) {
+  async deleteReturn(returnId, auth2 = SERVICE27) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/${encodeURIComponent(returnId)}`,
@@ -5494,7 +7320,7 @@ var ReturnsService = class {
 };
 
 // src/services/sepa-export.ts
-var SERVICE23 = { kind: "service" };
+var SERVICE28 = { kind: "service" };
 var SepaExportService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5505,7 +7331,7 @@ var SepaExportService = class {
     return `/sepa-export/${this.ctx.tenant}`;
   }
   /** Retrieve a SEPA export file by id. Returns the raw file content (text). */
-  async getFile(fileId, auth2 = SERVICE23) {
+  async getFile(fileId, auth2 = SERVICE28) {
     const path = `${this.base()}/files/${encodeURIComponent(fileId)}`;
     const res = await this.ctx.http.requestRaw({ method: "GET", path, auth: auth2 });
     if (!res.ok) {
@@ -5515,7 +7341,7 @@ var SepaExportService = class {
     return res.text();
   }
   /** List export jobs. */
-  async listJobs(query = {}, auth2 = SERVICE23) {
+  async listJobs(query = {}, auth2 = SERVICE28) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/jobs`,
@@ -5524,7 +7350,7 @@ var SepaExportService = class {
     });
   }
   /** Create an export job. */
-  async createJob(input, auth2 = SERVICE23) {
+  async createJob(input, auth2 = SERVICE28) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/jobs`,
@@ -5535,7 +7361,7 @@ var SepaExportService = class {
 };
 
 // src/services/indexing.ts
-var SERVICE24 = { kind: "service" };
+var SERVICE29 = { kind: "service" };
 var IndexingService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5546,11 +7372,11 @@ var IndexingService = class {
     return `/indexing/${this.ctx.tenant}`;
   }
   /** List indexing configurations. */
-  async listConfigurations(auth2 = SERVICE24) {
+  async listConfigurations(auth2 = SERVICE29) {
     return this.ctx.http.request({ method: "GET", path: `${this.base()}/configurations`, auth: auth2 });
   }
   /** Get a configuration by provider name. */
-  async getConfiguration(provider, auth2 = SERVICE24) {
+  async getConfiguration(provider, auth2 = SERVICE29) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/configurations/${encodeURIComponent(provider)}`,
@@ -5558,7 +7384,7 @@ var IndexingService = class {
     });
   }
   /** Create a configuration. */
-  async createConfiguration(input, auth2 = SERVICE24) {
+  async createConfiguration(input, auth2 = SERVICE29) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/configurations`,
@@ -5567,7 +7393,7 @@ var IndexingService = class {
     });
   }
   /** Update a configuration by provider name. */
-  async updateConfiguration(provider, input, auth2 = SERVICE24) {
+  async updateConfiguration(provider, input, auth2 = SERVICE29) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/configurations/${encodeURIComponent(provider)}`,
@@ -5576,7 +7402,7 @@ var IndexingService = class {
     });
   }
   /** Delete a configuration by provider name. */
-  async deleteConfiguration(provider, auth2 = SERVICE24) {
+  async deleteConfiguration(provider, auth2 = SERVICE29) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/configurations/${encodeURIComponent(provider)}`,
@@ -5584,11 +7410,11 @@ var IndexingService = class {
     });
   }
   /** List public indexing configurations. */
-  async listPublicConfigurations(auth2 = SERVICE24) {
+  async listPublicConfigurations(auth2 = SERVICE29) {
     return this.ctx.http.request({ method: "GET", path: `${this.base()}/public/configurations`, auth: auth2 });
   }
   /** Get a public configuration by provider name. */
-  async getPublicConfiguration(provider, auth2 = SERVICE24) {
+  async getPublicConfiguration(provider, auth2 = SERVICE29) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/public/configurations/${encodeURIComponent(provider)}`,
@@ -5601,7 +7427,7 @@ var IndexingService = class {
    * (PRODUCT only). Resolves to the created job (`201`) or, when a job for that
    * `entityType` is already `IN_PROGRESS`, that running job (`200`).
    */
-  async createReindexJob(input, auth2 = SERVICE24) {
+  async createReindexJob(input, auth2 = SERVICE29) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/reindex-jobs`,
@@ -5610,7 +7436,7 @@ var IndexingService = class {
     });
   }
   /** List reindex jobs (paginated). */
-  async listReindexJobs(opts = {}, auth2 = SERVICE24) {
+  async listReindexJobs(opts = {}, auth2 = SERVICE29) {
     const pageNumber = opts.pageNumber ?? 1;
     const pageSize = opts.pageSize ?? 50;
     const query = { pageNumber, pageSize };
@@ -5624,7 +7450,7 @@ var IndexingService = class {
     return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
   }
   /** Fetch one reindex job by id. */
-  async getReindexJob(reindexJobId, auth2 = SERVICE24) {
+  async getReindexJob(reindexJobId, auth2 = SERVICE29) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/reindex-jobs/${encodeURIComponent(reindexJobId)}`,
@@ -5636,13 +7462,13 @@ var IndexingService = class {
    * @deprecated since 2026-06-18, removal 2026-12-01 — use {@link createReindexJob}
    * (`createReindexJob({ entityType: "PRODUCT" })`), which returns a trackable job.
    */
-  async reindex(input, auth2 = SERVICE24) {
+  async reindex(input, auth2 = SERVICE29) {
     await this.ctx.http.request({ method: "POST", path: `${this.base()}/reindex`, auth: auth2, body: input });
   }
 };
 
 // src/services/unit-handling.ts
-var SERVICE25 = { kind: "service" };
+var SERVICE30 = { kind: "service" };
 var UnitHandlingService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5653,7 +7479,7 @@ var UnitHandlingService = class {
     return `/unit-handling/${this.ctx.tenant}`;
   }
   /** Find units (filter/sort/page). */
-  async listUnits(query = {}, auth2 = SERVICE25) {
+  async listUnits(query = {}, auth2 = SERVICE30) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/units`,
@@ -5662,7 +7488,7 @@ var UnitHandlingService = class {
     });
   }
   /** Retrieve a unit by code. */
-  async getUnit(unitCode, auth2 = SERVICE25) {
+  async getUnit(unitCode, auth2 = SERVICE30) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/units/${encodeURIComponent(unitCode)}`,
@@ -5670,11 +7496,11 @@ var UnitHandlingService = class {
     });
   }
   /** Add a new unit. */
-  async createUnit(input, auth2 = SERVICE25) {
+  async createUnit(input, auth2 = SERVICE30) {
     return this.ctx.http.request({ method: "POST", path: `${this.base()}/units`, auth: auth2, body: input });
   }
   /** Update a unit by code. */
-  async updateUnit(unitCode, input, auth2 = SERVICE25) {
+  async updateUnit(unitCode, input, auth2 = SERVICE30) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/units/${encodeURIComponent(unitCode)}`,
@@ -5683,7 +7509,7 @@ var UnitHandlingService = class {
     });
   }
   /** Delete a unit by code. */
-  async deleteUnit(unitCode, auth2 = SERVICE25) {
+  async deleteUnit(unitCode, auth2 = SERVICE30) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/units/${encodeURIComponent(unitCode)}`,
@@ -5691,7 +7517,7 @@ var UnitHandlingService = class {
     });
   }
   /** Delete multiple units by code (bulk). The codes are sent as the request body. */
-  async deleteUnits(codes, auth2 = SERVICE25) {
+  async deleteUnits(codes, auth2 = SERVICE30) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/units`,
@@ -5700,7 +7526,7 @@ var UnitHandlingService = class {
     });
   }
   /** Fetch a conversion factor (`PUT /units/conversion-factor-commands`). */
-  async getConversionFactor(input, auth2 = SERVICE25) {
+  async getConversionFactor(input, auth2 = SERVICE30) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/units/conversion-factor-commands`,
@@ -5709,7 +7535,7 @@ var UnitHandlingService = class {
     });
   }
   /** Convert a value between units (`PUT /units/convert-unit-commands`). */
-  async convertUnit(input, auth2 = SERVICE25) {
+  async convertUnit(input, auth2 = SERVICE30) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/units/convert-unit-commands`,
@@ -5718,13 +7544,13 @@ var UnitHandlingService = class {
     });
   }
   /** List all unit types. */
-  async listUnitTypes(auth2 = SERVICE25) {
+  async listUnitTypes(auth2 = SERVICE30) {
     return this.ctx.http.request({ method: "GET", path: `${this.base()}/types`, auth: auth2 });
   }
 };
 
 // src/services/catalog.ts
-var SERVICE26 = { kind: "service" };
+var SERVICE31 = { kind: "service" };
 var CatalogService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5735,7 +7561,7 @@ var CatalogService = class {
     return `/catalog/${this.ctx.tenant}/catalogs`;
   }
   /** List catalogs (filtered/sorted). */
-  async listCatalogs(query = {}, auth2 = SERVICE26) {
+  async listCatalogs(query = {}, auth2 = SERVICE31) {
     return this.ctx.http.request({
       method: "GET",
       path: this.base(),
@@ -5744,7 +7570,7 @@ var CatalogService = class {
     });
   }
   /** Retrieve a catalog by id. */
-  async getCatalog(catalogId, auth2 = SERVICE26) {
+  async getCatalog(catalogId, auth2 = SERVICE31) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/${encodeURIComponent(catalogId)}`,
@@ -5752,7 +7578,7 @@ var CatalogService = class {
     });
   }
   /** Retrieve all catalogs that contain a category. */
-  async getCatalogsForCategory(categoryId, auth2 = SERVICE26) {
+  async getCatalogsForCategory(categoryId, auth2 = SERVICE31) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/categories/${encodeURIComponent(categoryId)}`,
@@ -5760,11 +7586,11 @@ var CatalogService = class {
     });
   }
   /** Create a catalog. */
-  async createCatalog(input, auth2 = SERVICE26) {
+  async createCatalog(input, auth2 = SERVICE31) {
     return this.ctx.http.request({ method: "POST", path: this.base(), auth: auth2, body: input });
   }
   /** Upsert a catalog by id (`PUT`). */
-  async updateCatalog(catalogId, input, auth2 = SERVICE26) {
+  async updateCatalog(catalogId, input, auth2 = SERVICE31) {
     return this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/${encodeURIComponent(catalogId)}`,
@@ -5773,7 +7599,7 @@ var CatalogService = class {
     });
   }
   /** Partially update a catalog by id (`PATCH`). */
-  async patchCatalog(catalogId, patch, auth2 = SERVICE26) {
+  async patchCatalog(catalogId, patch, auth2 = SERVICE31) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/${encodeURIComponent(catalogId)}`,
@@ -5782,7 +7608,7 @@ var CatalogService = class {
     });
   }
   /** Remove a catalog by id. */
-  async deleteCatalog(catalogId, auth2 = SERVICE26) {
+  async deleteCatalog(catalogId, auth2 = SERVICE31) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/${encodeURIComponent(catalogId)}`,
@@ -5792,7 +7618,7 @@ var CatalogService = class {
 };
 
 // src/services/vendor.ts
-var SERVICE27 = { kind: "service" };
+var SERVICE32 = { kind: "service" };
 var VendorService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5804,7 +7630,7 @@ var VendorService = class {
   }
   // --- Vendors ---
   /** List all vendors. */
-  async listVendors(query = {}, auth2 = SERVICE27) {
+  async listVendors(query = {}, auth2 = SERVICE32) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/vendors`,
@@ -5813,7 +7639,7 @@ var VendorService = class {
     });
   }
   /** Retrieve a vendor by id. */
-  async getVendor(vendorId, auth2 = SERVICE27) {
+  async getVendor(vendorId, auth2 = SERVICE32) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/vendors/${encodeURIComponent(vendorId)}`,
@@ -5821,7 +7647,7 @@ var VendorService = class {
     });
   }
   /** Search vendors (`POST /vendors/search`). A built filter in `q` is resolved to a string. */
-  async searchVendors(query, auth2 = SERVICE27) {
+  async searchVendors(query, auth2 = SERVICE32) {
     const body = query.q !== void 0 ? { ...query, q: resolveQuery(query.q, { compoundLogicalQuery: false }) } : query;
     return this.ctx.http.request({
       method: "POST",
@@ -5831,11 +7657,11 @@ var VendorService = class {
     });
   }
   /** Create a vendor. */
-  async createVendor(input, auth2 = SERVICE27) {
+  async createVendor(input, auth2 = SERVICE32) {
     return this.ctx.http.request({ method: "POST", path: `${this.base()}/vendors`, auth: auth2, body: input });
   }
   /** Upsert a vendor by id (`PUT`). */
-  async updateVendor(vendorId, input, auth2 = SERVICE27) {
+  async updateVendor(vendorId, input, auth2 = SERVICE32) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/vendors/${encodeURIComponent(vendorId)}`,
@@ -5844,7 +7670,7 @@ var VendorService = class {
     });
   }
   /** Delete a vendor by id. */
-  async deleteVendor(vendorId, auth2 = SERVICE27) {
+  async deleteVendor(vendorId, auth2 = SERVICE32) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/vendors/${encodeURIComponent(vendorId)}`,
@@ -5853,7 +7679,7 @@ var VendorService = class {
   }
   // --- Vendor locations ---
   /** List all vendor locations. */
-  async listVendorLocations(query = {}, auth2 = SERVICE27) {
+  async listVendorLocations(query = {}, auth2 = SERVICE32) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/locations`,
@@ -5862,7 +7688,7 @@ var VendorService = class {
     });
   }
   /** Retrieve a vendor location by id. */
-  async getVendorLocation(locationId, auth2 = SERVICE27) {
+  async getVendorLocation(locationId, auth2 = SERVICE32) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/locations/${encodeURIComponent(locationId)}`,
@@ -5870,11 +7696,11 @@ var VendorService = class {
     });
   }
   /** Create a vendor location. */
-  async createVendorLocation(input, auth2 = SERVICE27) {
+  async createVendorLocation(input, auth2 = SERVICE32) {
     return this.ctx.http.request({ method: "POST", path: `${this.base()}/locations`, auth: auth2, body: input });
   }
   /** Upsert a vendor location by id (`PUT`). */
-  async updateVendorLocation(locationId, input, auth2 = SERVICE27) {
+  async updateVendorLocation(locationId, input, auth2 = SERVICE32) {
     await this.ctx.http.request({
       method: "PUT",
       path: `${this.base()}/locations/${encodeURIComponent(locationId)}`,
@@ -5883,7 +7709,7 @@ var VendorService = class {
     });
   }
   /** Delete a vendor location by id. */
-  async deleteVendorLocation(locationId, auth2 = SERVICE27) {
+  async deleteVendorLocation(locationId, auth2 = SERVICE32) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/locations/${encodeURIComponent(locationId)}`,
@@ -5893,7 +7719,7 @@ var VendorService = class {
 };
 
 // src/services/pick-pack.ts
-var SERVICE28 = { kind: "service" };
+var SERVICE33 = { kind: "service" };
 var PickPackService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -5907,7 +7733,7 @@ var PickPackService = class {
     return `${this.base()}/orders/${encodeURIComponent(orderId)}`;
   }
   /** List packlist orders. */
-  async listOrders(query = {}, auth2 = SERVICE28) {
+  async listOrders(query = {}, auth2 = SERVICE33) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/orders`,
@@ -5916,19 +7742,19 @@ var PickPackService = class {
     });
   }
   /** Retrieve a packlist order by id. */
-  async getOrder(orderId, auth2 = SERVICE28) {
+  async getOrder(orderId, auth2 = SERVICE33) {
     return this.ctx.http.request({ method: "GET", path: this.orderPath(orderId), auth: auth2 });
   }
   /** Update an order's status (`PATCH`). Returns an acknowledgement. */
-  async updateOrder(orderId, change, auth2 = SERVICE28) {
+  async updateOrder(orderId, change, auth2 = SERVICE33) {
     return this.ctx.http.request({ method: "PATCH", path: this.orderPath(orderId), auth: auth2, body: change });
   }
   /** Finish an order. Returns an acknowledgement. */
-  async finishOrder(orderId, auth2 = SERVICE28) {
+  async finishOrder(orderId, auth2 = SERVICE33) {
     return this.ctx.http.request({ method: "POST", path: `${this.orderPath(orderId)}/finish`, auth: auth2 });
   }
   /** List order cycles (ids). */
-  async listOrderCycles(query = {}, auth2 = SERVICE28) {
+  async listOrderCycles(query = {}, auth2 = SERVICE33) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/orderCycles`,
@@ -5937,11 +7763,11 @@ var PickPackService = class {
     });
   }
   /** Add an assignee to an order. Returns an acknowledgement. */
-  async addAssignee(orderId, assignee, auth2 = SERVICE28) {
+  async addAssignee(orderId, assignee, auth2 = SERVICE33) {
     return this.ctx.http.request({ method: "POST", path: `${this.orderPath(orderId)}/assignees`, auth: auth2, body: assignee });
   }
   /** Remove an assignee from an order. */
-  async removeAssignee(orderId, assigneeId, auth2 = SERVICE28) {
+  async removeAssignee(orderId, assigneeId, auth2 = SERVICE33) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.orderPath(orderId)}/assignees/${encodeURIComponent(assigneeId)}`,
@@ -5949,15 +7775,15 @@ var PickPackService = class {
     });
   }
   /** Update packaging products for an order (`PUT`). Returns an acknowledgement. */
-  async updatePackaging(orderId, change, auth2 = SERVICE28) {
+  async updatePackaging(orderId, change, auth2 = SERVICE33) {
     return this.ctx.http.request({ method: "PUT", path: `${this.orderPath(orderId)}/packaging`, auth: auth2, body: change });
   }
   /** Create a packing event. Returns an acknowledgement. */
-  async createEvent(event, auth2 = SERVICE28) {
+  async createEvent(event, auth2 = SERVICE33) {
     return this.ctx.http.request({ method: "POST", path: `${this.base()}/events`, auth: auth2, body: event });
   }
   /** List packing events. */
-  async listEvents(query = {}, auth2 = SERVICE28) {
+  async listEvents(query = {}, auth2 = SERVICE33) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/events`,
@@ -5966,7 +7792,7 @@ var PickPackService = class {
     });
   }
   /** Trigger an order recalculation. Returns the created job's id. */
-  async triggerRecalculation(input, auth2 = SERVICE28) {
+  async triggerRecalculation(input, auth2 = SERVICE33) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/jobs/recalculations`,
@@ -5975,7 +7801,7 @@ var PickPackService = class {
     });
   }
   /** Retrieve a recalculation job by id. */
-  async getRecalculationJob(jobId, auth2 = SERVICE28) {
+  async getRecalculationJob(jobId, auth2 = SERVICE33) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/jobs/recalculations/${encodeURIComponent(jobId)}`,
@@ -5985,7 +7811,7 @@ var PickPackService = class {
 };
 
 // src/services/customer-admin.ts
-var SERVICE29 = { kind: "service" };
+var SERVICE34 = { kind: "service" };
 var CustomerAdminService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -6003,7 +7829,7 @@ var CustomerAdminService = class {
   }
   // --- Customers ---
   /** List customers. */
-  async listCustomers(query = {}, auth2 = SERVICE29) {
+  async listCustomers(query = {}, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "GET",
       path: this.base(),
@@ -6012,33 +7838,33 @@ var CustomerAdminService = class {
     });
   }
   /** Search customers (`POST /customers/search`). A built filter in `q` is resolved to a string. */
-  async searchCustomers(query, auth2 = SERVICE29) {
+  async searchCustomers(query, auth2 = SERVICE34) {
     const body = query.q !== void 0 ? { ...query, q: resolveQuery(query.q, { compoundLogicalQuery: false }) } : query;
     return this.ctx.http.request({ method: "POST", path: `${this.base()}/search`, auth: auth2, body });
   }
   /** Retrieve a customer profile by number. */
-  async getCustomer(customerNumber, auth2 = SERVICE29) {
+  async getCustomer(customerNumber, auth2 = SERVICE34) {
     return this.ctx.http.request({ method: "GET", path: this.customerPath(customerNumber), auth: auth2 });
   }
   /** Create a customer. */
-  async createCustomer(input, auth2 = SERVICE29) {
+  async createCustomer(input, auth2 = SERVICE34) {
     return this.ctx.http.request({ method: "POST", path: this.base(), auth: auth2, body: input });
   }
   /** Upsert a customer profile by number (`PUT`). */
-  async upsertCustomer(customerNumber, input, auth2 = SERVICE29) {
+  async upsertCustomer(customerNumber, input, auth2 = SERVICE34) {
     return this.ctx.http.request({ method: "PUT", path: this.customerPath(customerNumber), auth: auth2, body: input });
   }
   /** Partially update a customer profile (`PATCH`). */
-  async patchCustomer(customerNumber, patch, auth2 = SERVICE29) {
+  async patchCustomer(customerNumber, patch, auth2 = SERVICE34) {
     await this.ctx.http.request({ method: "PATCH", path: this.customerPath(customerNumber), auth: auth2, body: patch });
   }
   /** Delete a customer profile. */
-  async deleteCustomer(customerNumber, auth2 = SERVICE29) {
+  async deleteCustomer(customerNumber, auth2 = SERVICE34) {
     await this.ctx.http.request({ method: "DELETE", path: this.customerPath(customerNumber), auth: auth2 });
   }
   // --- Addresses ---
   /** List a customer's addresses. */
-  async listAddresses(customerNumber, auth2 = SERVICE29) {
+  async listAddresses(customerNumber, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.customerPath(customerNumber)}/addresses`,
@@ -6046,11 +7872,11 @@ var CustomerAdminService = class {
     });
   }
   /** Retrieve one address. */
-  async getAddress(customerNumber, addressId, auth2 = SERVICE29) {
+  async getAddress(customerNumber, addressId, auth2 = SERVICE34) {
     return this.ctx.http.request({ method: "GET", path: this.addressPath(customerNumber, addressId), auth: auth2 });
   }
   /** Add an address. */
-  async addAddress(customerNumber, input, auth2 = SERVICE29) {
+  async addAddress(customerNumber, input, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.customerPath(customerNumber)}/addresses`,
@@ -6059,19 +7885,19 @@ var CustomerAdminService = class {
     });
   }
   /** Upsert an address by id (`PUT`). */
-  async upsertAddress(customerNumber, addressId, input, auth2 = SERVICE29) {
+  async upsertAddress(customerNumber, addressId, input, auth2 = SERVICE34) {
     return this.ctx.http.request({ method: "PUT", path: this.addressPath(customerNumber, addressId), auth: auth2, body: input });
   }
   /** Partially update an address by id (`PATCH`). */
-  async patchAddress(customerNumber, addressId, patch, auth2 = SERVICE29) {
+  async patchAddress(customerNumber, addressId, patch, auth2 = SERVICE34) {
     await this.ctx.http.request({ method: "PATCH", path: this.addressPath(customerNumber, addressId), auth: auth2, body: patch });
   }
   /** Delete an address by id. */
-  async deleteAddress(customerNumber, addressId, auth2 = SERVICE29) {
+  async deleteAddress(customerNumber, addressId, auth2 = SERVICE34) {
     await this.ctx.http.request({ method: "DELETE", path: this.addressPath(customerNumber, addressId), auth: auth2 });
   }
   /** Add tags to an address (`?tags=` query). */
-  async addAddressTags(customerNumber, addressId, tags, auth2 = SERVICE29) {
+  async addAddressTags(customerNumber, addressId, tags, auth2 = SERVICE34) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.addressPath(customerNumber, addressId)}/tags`,
@@ -6080,7 +7906,7 @@ var CustomerAdminService = class {
     });
   }
   /** Remove tags from an address (`?tags=` query). */
-  async removeAddressTags(customerNumber, addressId, tags, auth2 = SERVICE29) {
+  async removeAddressTags(customerNumber, addressId, tags, auth2 = SERVICE34) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.addressPath(customerNumber, addressId)}/tags`,
@@ -6091,7 +7917,7 @@ var CustomerAdminService = class {
 };
 
 // src/services/approval.ts
-var SERVICE30 = { kind: "service" };
+var SERVICE35 = { kind: "service" };
 var ApprovalService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -6102,7 +7928,7 @@ var ApprovalService = class {
     return `/approval/${this.ctx.tenant}`;
   }
   /** List approvals (paged via `pageNumber`/`pageSize`/`sort`/`q`). Returns an array. */
-  async listApprovals(query = {}, auth2 = SERVICE30) {
+  async listApprovals(query = {}, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/approvals`,
@@ -6111,7 +7937,7 @@ var ApprovalService = class {
     });
   }
   /** Retrieve a single approval by id. */
-  async getApproval(approvalId, auth2 = SERVICE30) {
+  async getApproval(approvalId, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/approvals/${encodeURIComponent(approvalId)}`,
@@ -6119,7 +7945,7 @@ var ApprovalService = class {
     });
   }
   /** Create an approval request (cart or quote). Returns the created `{ id }`. */
-  async createApproval(input, auth2 = SERVICE30) {
+  async createApproval(input, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/approvals`,
@@ -6128,7 +7954,7 @@ var ApprovalService = class {
     });
   }
   /** Approve/reject/amend an approval via a JSON-Patch op-array (`PATCH`). */
-  async updateApproval(approvalId, ops, auth2 = SERVICE30) {
+  async updateApproval(approvalId, ops, auth2 = SERVICE35) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/approvals/${encodeURIComponent(approvalId)}`,
@@ -6137,7 +7963,7 @@ var ApprovalService = class {
     });
   }
   /** Delete an approval by id. */
-  async deleteApproval(approvalId, auth2 = SERVICE30) {
+  async deleteApproval(approvalId, auth2 = SERVICE35) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/approvals/${encodeURIComponent(approvalId)}`,
@@ -6145,7 +7971,7 @@ var ApprovalService = class {
     });
   }
   /** Check whether an operation on a resource is permitted / needs approval. */
-  async checkPermitted(input, auth2 = SERVICE30) {
+  async checkPermitted(input, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/approval/permitted`,
@@ -6154,7 +7980,7 @@ var ApprovalService = class {
     });
   }
   /** Search for users eligible to approve a resource. Returns an array. */
-  async searchApprovers(input, auth2 = SERVICE30) {
+  async searchApprovers(input, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/search/users`,
@@ -6181,6 +8007,7 @@ var EmporixClient = class {
   contacts;
   locations;
   customerGroups;
+  iam;
   orders;
   salesOrders;
   availability;
@@ -6254,6 +8081,7 @@ var EmporixClient = class {
     this.contacts = new ContactsService(mk(ContactsService.channel));
     this.locations = new LocationsService(mk(LocationsService.channel));
     this.customerGroups = new CustomerGroupsService(mk(CustomerGroupsService.channel));
+    this.iam = new IamService(mk(IamService.channel));
     this.orders = new OrdersService(mk(OrdersService.channel));
     this.salesOrders = new SalesOrdersService(mk(SalesOrdersService.channel));
     this.availability = new AvailabilityService(mk(AvailabilityService.channel));
@@ -6383,6 +8211,7 @@ exports.EmporixTimeoutError = EmporixTimeoutError;
 exports.EmporixValidationError = EmporixValidationError;
 exports.FeeService = FeeService;
 exports.HttpClient = HttpClient;
+exports.IamService = IamService;
 exports.IndexingService = IndexingService;
 exports.InvoiceService = InvoiceService;
 exports.LEVEL = LEVEL;