@viu/emporix-sdk 2.2.0 → 2.4.0

package/dist/index.cjs

@@ -2385,8 +2385,2130 @@ var ClientConfigService = class {
   }
 };
 
+// src/services/shopping-list.ts
+var RESERVED = /* @__PURE__ */ new Set(["customerId", "metadata"]);
+var ShoppingListService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/shoppinglist/${this.ctx.tenant}/shopping-lists`;
+  }
+  /** The caller's lists (or, with employee scope, all), normalized to an array. */
+  async list(auth2, opts = {}) {
+    const envelopes = await this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      auth: auth2,
+      ...opts.name ? { query: { name: opts.name } } : {}
+    });
+    const out = [];
+    for (const env of envelopes ?? []) {
+      for (const [key, value] of Object.entries(env)) {
+        if (RESERVED.has(key) || value === null || typeof value !== "object") continue;
+        const v = value;
+        out.push({
+          key,
+          name: v.name ?? key,
+          items: v.items ?? [],
+          ...v.mixins ? { mixins: v.mixins } : {},
+          ...v.metadata ? { metadata: v.metadata } : {}
+        });
+      }
+    }
+    return out;
+  }
+  /** Create a list; returns the new list id. */
+  async create(draft, auth2) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(),
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Replace the named list (low-level PUT). */
+  async replace(customerId, draft, auth2) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${encodeURIComponent(customerId)}`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Delete the named list, or all the customer's lists when `name` is omitted. */
+  async delete(customerId, auth2, opts = {}) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${encodeURIComponent(customerId)}`,
+      auth: auth2,
+      ...opts.name ? { query: { name: opts.name } } : {}
+    });
+  }
+  async loadList(listName, auth2) {
+    const lists = await this.list(auth2, { name: listName });
+    const found = lists.find((l) => l.name === listName);
+    if (!found) throw new EmporixNotFoundError(`Shopping list "${listName}" not found`, 404);
+    return found;
+  }
+  async put(customerId, list, items, auth2) {
+    await this.replace(
+      customerId,
+      { name: list.name, items, ...list.mixins ? { mixins: list.mixins } : {} },
+      auth2
+    );
+  }
+  /** Add/replace an item by `productId` (read-modify-write, last-write-wins). */
+  async addItem(customerId, listName, item, auth2) {
+    const list = await this.loadList(listName, auth2);
+    const items = [...list.items.filter((i) => i.productId !== item.productId), item];
+    await this.put(customerId, list, items, auth2);
+  }
+  /** Remove an item by `productId` (no-op if absent). */
+  async removeItem(customerId, listName, productId, auth2) {
+    const list = await this.loadList(listName, auth2);
+    const items = list.items.filter((i) => i.productId !== productId);
+    await this.put(customerId, list, items, auth2);
+  }
+  /** Set an item's quantity; `quantity <= 0` removes it. Adds the item if absent. */
+  async setItemQuantity(customerId, listName, productId, quantity, auth2) {
+    if (quantity <= 0) return this.removeItem(customerId, listName, productId, auth2);
+    const list = await this.loadList(listName, auth2);
+    let items = list.items.map((i) => i.productId === productId ? { ...i, quantity } : i);
+    if (!items.some((i) => i.productId === productId)) items = [...items, { productId, quantity }];
+    await this.put(customerId, list, items, auth2);
+  }
+};
+
+// src/services/ai-rag-indexer.ts
+var SERVICE5 = { kind: "service" };
+var RagIndexerService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base(type) {
+    return `/ai-rag-indexer/${this.ctx.tenant}/${encodeURIComponent(type)}`;
+  }
+  /** The indexable embedding field names for `type` (default `"PRODUCT"`). */
+  async ragMetadata(type = "PRODUCT", auth2 = SERVICE5) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base(type)}/rag-metadata`,
+      auth: auth2
+    });
+  }
+  /** The filterable metadata fields for `type` (default `"PRODUCT"`). */
+  async filterMetadata(type = "PRODUCT", auth2 = SERVICE5) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base(type)}/filter-metadata`,
+      auth: auth2
+    });
+  }
+  /**
+   * Schedule a full asynchronous re-index for `type` (default `"PRODUCT"`).
+   * Resolves once the rebuild is *scheduled* (HTTP 204); there is no progress
+   * to await or poll. Costly — avoid calling on a hot path.
+   */
+  async reindex(type = "PRODUCT", auth2 = SERVICE5) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base(type)}/reindex`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/sequential-id.ts
+var SERVICE6 = { kind: "service" };
+var SequentialIdService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/sequential-id/${this.ctx.tenant}/schemas`;
+  }
+  /** List all sequence schemas for the tenant. */
+  async listSchemas(auth2 = SERVICE6) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      auth: auth2
+    });
+  }
+  /** Retrieve one sequence schema by id. */
+  async getSchema(schemaId, auth2 = SERVICE6) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${encodeURIComponent(schemaId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a sequence schema. Schemas are immutable — there is no update. */
+  async createSchema(schema, auth2 = SERVICE6) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(),
+      auth: auth2,
+      body: schema
+    });
+  }
+  /** Delete a sequence schema by id. */
+  async deleteSchema(schemaId, auth2 = SERVICE6) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${encodeURIComponent(schemaId)}`,
+      auth: auth2
+    });
+  }
+  /** Mark a schema active for its type (only one schema may be active per type). */
+  async setActiveSchema(schemaId, auth2 = SERVICE6) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/${encodeURIComponent(schemaId)}/setActive`,
+      auth: auth2
+    });
+  }
+  /** Get the active schema for a given schema type. */
+  async listSchemasByType(schemaType, auth2 = SERVICE6) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/types/${encodeURIComponent(schemaType)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Generate the next id for a schema type. `body` carries an optional
+   * `sequenceKey` (independent sub-pool counter) and `placeholders`.
+   * `opts.siteCode` derives time/country placeholders from the site's settings.
+   */
+  async nextId(schemaType, body = {}, opts = {}, auth2 = SERVICE6) {
+    const query = opts.siteCode ? { siteCode: opts.siteCode } : void 0;
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/types/${encodeURIComponent(schemaType)}/nextId`,
+      auth: auth2,
+      body,
+      ...query ? { query } : {}
+    });
+  }
+  /**
+   * Generate next ids for multiple schema types in one call. NOTE: the batch
+   * endpoint path omits the `{tenant}` segment — the service derives the
+   * tenant from the token.
+   */
+  async nextIdsBatch(req, auth2 = SERVICE6) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `/sequential-id/sequenceSchemaBatch/nextIds`,
+      auth: auth2,
+      body: req
+    });
+  }
+};
+
+// src/services/fee.ts
+var SERVICE7 = { kind: "service" };
+var FeeService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  feesBase() {
+    return `/fee/${this.ctx.tenant}/fees`;
+  }
+  itemFeesBase() {
+    return `/fee/${this.ctx.tenant}/itemFees`;
+  }
+  productFeesBase() {
+    return `/fee/${this.ctx.tenant}/productFees`;
+  }
+  // --- Fee definitions ---
+  /**
+   * List fee definitions, wrapped in the shared {@link PaginatedItems}
+   * envelope (same heuristic as `media.list`: `hasNextPage` is true when the
+   * returned page is full). Defaults match Emporix server defaults
+   * (`pageNumber: 1`, `pageSize: 60`).
+   */
+  async list(query = {}, auth2 = SERVICE7) {
+    const pageNumber = query.pageNumber ?? 1;
+    const pageSize = query.pageSize ?? 60;
+    const items = await this.ctx.http.request({
+      method: "GET",
+      path: this.feesBase(),
+      auth: auth2,
+      query: { ...query, pageNumber, pageSize }
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  /** Retrieve one fee definition by id. */
+  async get(id, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.feesBase()}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /** Create a fee definition. */
+  async create(draft, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.feesBase(),
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Update a fee definition by id. */
+  async update(id, draft, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.feesBase()}/${encodeURIComponent(id)}`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Delete a fee definition by id. */
+  async delete(id, auth2 = SERVICE7) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.feesBase()}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  // --- Item-fee mappings ---
+  /** List all item-fee mappings. */
+  async listItemFees(auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.itemFeesBase(),
+      auth: auth2
+    });
+  }
+  /** Fee mappings for one item YRN. */
+  async getItemFees(itemYrn, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.itemFeesBase()}/${encodeURIComponent(itemYrn)}/fees`,
+      auth: auth2
+    });
+  }
+  /** Create an item-fee mapping. */
+  async createItemFee(draft, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.itemFeesBase(),
+      auth: auth2,
+      body: draft
+    });
+  }
+  /**
+   * 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 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.itemFeesBase()}/${encodeURIComponent(itemYrn)}/fees`,
+      auth: auth2,
+      body: { feeIds },
+      ...opts.partial ? { query: { partial: "true" } } : {}
+    });
+  }
+  /**
+   * 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 = SERVICE7) {
+    const base = `${this.itemFeesBase()}/${encodeURIComponent(itemYrn)}/fees`;
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: feeId ? `${base}/${encodeURIComponent(feeId)}` : base,
+      auth: auth2
+    });
+  }
+  /** Search item-fee mappings by item YRNs + site. */
+  async searchItemFees(search, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.itemFeesBase()}/search`,
+      auth: auth2,
+      body: search
+    });
+  }
+  // --- Product-fee mappings ---
+  /** Fee mappings for a product id. */
+  async getProductFees(productId, auth2 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.productFeesBase()}/${encodeURIComponent(productId)}/fees`,
+      auth: auth2
+    });
+  }
+  /**
+   * 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 = SERVICE7) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.productFeesBase()}/${encodeURIComponent(productId)}/fees`,
+      auth: auth2,
+      body: { feeIds },
+      ...opts.partial ? { query: { partial: "true" } } : {}
+    });
+  }
+  /** Delete all fee mappings for a product id. */
+  async deleteProductFees(productId, auth2 = SERVICE7) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.productFeesBase()}/${encodeURIComponent(productId)}/fees`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/webhook.ts
+var SERVICE8 = { kind: "service" };
+var WebhookService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/webhook/${this.ctx.tenant}`;
+  }
+  /** List the event-subscription catalog with each event's on/off state. */
+  async listEventSubscriptions(auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/event-subscriptions`,
+      auth: auth2
+    });
+  }
+  /**
+   * Batch subscribe/unsubscribe events. Returns the **207** per-item result
+   * array verbatim — the batch can partially fail, so inspect each element's
+   * `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 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/event-subscriptions`,
+      auth: auth2,
+      body: items
+    });
+  }
+  /** List delivery configurations. */
+  async listConfigs(auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/config`,
+      auth: auth2
+    });
+  }
+  /** Retrieve one delivery configuration by code. */
+  async getConfig(code, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/config/${encodeURIComponent(code)}`,
+      auth: auth2
+    });
+  }
+  /** Create a delivery configuration. Returns the server-assigned `{ code }`. */
+  async createConfig(draft, auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/config`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Replace a delivery configuration by code (204). */
+  async replaceConfig(code, draft, auth2 = SERVICE8) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/config/${encodeURIComponent(code)}`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /**
+   * 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 = SERVICE8) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/config/${encodeURIComponent(code)}`,
+      auth: auth2,
+      body: patches
+    });
+  }
+  /**
+   * 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 = SERVICE8) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/config/${encodeURIComponent(code)}`,
+      auth: auth2,
+      ...opts.force === true ? { query: { force: "true" } } : {}
+    });
+  }
+  /** Read delivery statistics over an optional `YYYY-MM` range. */
+  async getStatistics(query = {}, auth2 = SERVICE8) {
+    const q = {};
+    if (query.fromYearMonth) q.fromYearMonth = query.fromYearMonth;
+    if (query.toYearMonth) q.toYearMonth = query.toYearMonth;
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/statistics`,
+      auth: auth2,
+      ...Object.keys(q).length > 0 ? { query: q } : {}
+    });
+  }
+  /** Obtain Svix dashboard access (URL / token). */
+  async getDashboardAccess(auth2 = SERVICE8) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/dashboard-access`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/schema.ts
+var SERVICE9 = { kind: "service" };
+var SchemaService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  schemasBase() {
+    return `/schema/${this.ctx.tenant}/schemas`;
+  }
+  entitiesBase() {
+    return `/schema/${this.ctx.tenant}/custom-entities`;
+  }
+  instancesBase(type) {
+    return `${this.entitiesBase()}/${encodeURIComponent(type)}/instances`;
+  }
+  // --- (A) Schemas ---------------------------------------------------------
+  /**
+   * List schemas, wrapped in the shared {@link PaginatedItems} envelope.
+   * `hasNextPage` is the standard SDK heuristic (`items.length === pageSize`).
+   * Pagination defaults match the rest of the SDK (`pageNumber: 1`,
+   * `pageSize: 60`).
+   */
+  async listSchemas(query = {}, auth2 = SERVICE9) {
+    const pageNumber = query.pageNumber ?? 1;
+    const pageSize = query.pageSize ?? 60;
+    const q = { pageNumber, pageSize };
+    if (query.q) q.q = query.q;
+    if (query.type) q.type = query.type;
+    const items = await this.ctx.http.request({
+      method: "GET",
+      path: this.schemasBase(),
+      auth: auth2,
+      query: q
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  /** Retrieve one schema by id. */
+  async getSchema(id, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.schemasBase()}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /** Create a schema. */
+  async createSchema(draft, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.schemasBase(),
+      auth: auth2,
+      body: draft
+    });
+  }
+  /**
+   * Update a schema. The upstream API requires `draft.metadata.version`; a
+   * stale version yields 409 Conflict (propagated as the standard conflict
+   * error).
+   */
+  async updateSchema(id, draft, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.schemasBase()}/${encodeURIComponent(id)}`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Delete a schema by id. */
+  async deleteSchema(id, auth2 = SERVICE9) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.schemasBase()}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Validate a schema document without persisting it (`POST /schemas/file`).
+   * Returns the server's validation result verbatim.
+   */
+  async validateSchemaFile(body, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.schemasBase()}/file`,
+      auth: auth2,
+      body
+    });
+  }
+  // --- (B) Types -----------------------------------------------------------
+  /** List entity types that currently have at least one schema. */
+  async listTypes(auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `/schema/${this.ctx.tenant}/types`,
+      auth: auth2
+    });
+  }
+  /** Set the entity types a schema applies to (`PUT /schemas/{id}/types`). */
+  async setSchemaTypes(id, types, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.schemasBase()}/${encodeURIComponent(id)}/types`,
+      auth: auth2,
+      body: { types }
+    });
+  }
+  // --- (C) Custom entities -------------------------------------------------
+  /** List custom-entity definitions. `expandSchemas` inlines each schema body. */
+  async listCustomEntities(opts = {}, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.entitiesBase(),
+      auth: auth2,
+      ...opts.expandSchemas ? { query: { expandSchemas: "true" } } : {}
+    });
+  }
+  /** Retrieve one custom-entity definition by id. */
+  async getCustomEntity(id, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.entitiesBase()}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /** Create a custom-entity definition. */
+  async createCustomEntity(draft, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.entitiesBase(),
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Update a custom-entity definition. */
+  async updateCustomEntity(id, draft, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.entitiesBase()}/${encodeURIComponent(id)}`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /**
+   * Delete a custom-entity definition. The server rejects with 409 if
+   * instances or schemas still reference it (propagated as the standard
+   * conflict error).
+   */
+  async deleteCustomEntity(id, auth2 = SERVICE9) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.entitiesBase()}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  // --- (D) Custom instances ------------------------------------------------
+  /**
+   * 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 = SERVICE9) {
+    const pageNumber = query.pageNumber ?? 1;
+    const pageSize = query.pageSize ?? 60;
+    const items = await this.ctx.http.request({
+      method: "GET",
+      path: this.instancesBase(type),
+      auth: auth2,
+      query: { ...query, pageNumber, pageSize }
+    });
+    return { items, pageNumber, pageSize, hasNextPage: items.length === pageSize };
+  }
+  /** Retrieve one instance by id. */
+  async getInstance(type, id, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /** Create an instance of a custom entity. */
+  async createInstance(type, draft, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.instancesBase(type),
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Replace an instance (full `PUT`). */
+  async replaceInstance(type, id, draft, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Partially update an instance (`PATCH`). */
+  async patchInstance(type, id, patch, auth2 = SERVICE9) {
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
+      auth: auth2,
+      body: patch
+    });
+  }
+  /** Delete an instance by id. */
+  async deleteInstance(type, id, auth2 = SERVICE9) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.instancesBase(type)}/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Structured search over a custom entity's instances
+   * (`POST /instances/search`), wrapped in {@link PaginatedItems}.
+   */
+  async searchInstances(type, body, auth2 = SERVICE9) {
+    const items = await this.ctx.http.request({
+      method: "POST",
+      path: `${this.instancesBase(type)}/search`,
+      auth: auth2,
+      body
+    });
+    return { items, pageNumber: 1, pageSize: items.length, hasNextPage: false };
+  }
+};
+
+// src/services/ai.ts
+var SERVICE10 = { kind: "service" };
+var AiService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/ai-service/${this.ctx.tenant}`;
+  }
+  /** Generate text from a single prompt (`POST /texts`). Honors `maxTokens`. */
+  async generateText(input, auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/texts`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Run a chat completion over a message list (`POST /completions`). No `maxTokens`. */
+  async complete(input, auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/completions`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** List all agentic agents. */
+  async listAgents(auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/agentic/agents`,
+      auth: auth2
+    });
+  }
+  /** Retrieve one agent by id. */
+  async getAgent(id, auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /** Create-or-replace an agent by id (`PUT`). Takes the agent write shape. */
+  async upsertAgent(id, agent, auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
+      auth: auth2,
+      body: agent
+    });
+  }
+  /**
+   * Patch an agent with an op array (`PATCH`). `ops` use the upstream
+   * UPPERCASE enum (`ADD | REMOVE | REPLACE`) and are sent verbatim — this is
+   * NOT RFC-6902 JSON-Patch.
+   */
+  async patchAgent(id, ops, auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
+      auth: auth2,
+      body: ops
+    });
+  }
+  /**
+   * Delete an agent by id. Pass `{ force: true }` to delete an agent that is
+   * still referenced elsewhere (`?force=true`).
+   */
+  async deleteAgent(id, auth2 = SERVICE10, opts = {}) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/agentic/agents/${encodeURIComponent(id)}`,
+      auth: auth2,
+      ...opts.force ? { query: { force: "true" } } : {}
+    });
+  }
+  /** Server-side agent search (`POST /agentic/agents/search`). */
+  async searchAgents(query, auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/agentic/agents/search`,
+      auth: auth2,
+      body: query
+    });
+  }
+  /**
+   * 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 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/agentic/chat`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /**
+   * Fire-and-forget agent chat (`POST /agentic/chat-async`, HTTP 201).
+   * Returns the job-id ARRAY verbatim.
+   */
+  async chatAsync(input, auth2 = SERVICE10) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/agentic/chat-async`,
+      auth: auth2,
+      body: input
+    });
+  }
+};
+
+// src/services/tax.ts
+var SERVICE11 = { kind: "service" };
+var TaxService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/tax/${this.ctx.tenant}`;
+  }
+  /** List all per-location tax configurations. */
+  async listTaxConfigs(auth2 = SERVICE11) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/taxes`,
+      auth: auth2
+    });
+  }
+  /** Retrieve one tax configuration by its location (country) code. */
+  async getTaxConfig(locationCode, auth2 = SERVICE11) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/taxes/${encodeURIComponent(locationCode)}`,
+      auth: auth2
+    });
+  }
+  /** Create a tax configuration (`POST`). Returns the created `{ locationCode }`. */
+  async createTaxConfig(input, auth2 = SERVICE11) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/taxes`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /**
+   * Update a tax configuration by location code (`PUT`). `metadata.version` is
+   * required (optimistic locking — a stale version yields 409).
+   */
+  async updateTaxConfig(locationCode, input, auth2 = SERVICE11) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/taxes/${encodeURIComponent(locationCode)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Delete a tax configuration by location code. */
+  async deleteTaxConfig(locationCode, auth2 = SERVICE11) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/taxes/${encodeURIComponent(locationCode)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Calculate net/gross values for a price (`PUT /taxes/calculation-commands`).
+   * Single command in, single result out.
+   */
+  async calculateTax(request, auth2 = SERVICE11) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/taxes/calculation-commands`,
+      auth: auth2,
+      body: request
+    });
+  }
+};
+
+// src/services/coupon.ts
+var SERVICE12 = { kind: "service" };
+var CouponService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/coupon/${this.ctx.tenant}`;
+  }
+  /** List coupons by criteria. Returns a plain array. */
+  async listCoupons(query = {}, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/coupons`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one coupon by code. */
+  async getCoupon(code, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
+      auth: auth2
+    });
+  }
+  /** Create a coupon (`POST`, HTTP 201). Returns the created resource's `{ id?, yrn? }`. */
+  async createCoupon(input, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/coupons`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Replace a coupon by code (`PUT`). Resolves once the update is accepted. */
+  async updateCoupon(code, input, auth2 = SERVICE12) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Partially update a coupon by code (`PATCH` merge body). */
+  async patchCoupon(code, patch, auth2 = SERVICE12) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
+      auth: auth2,
+      body: patch
+    });
+  }
+  /** Delete a coupon by code. */
+  async deleteCoupon(code, auth2 = SERVICE12) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}`,
+      auth: auth2
+    });
+  }
+  /**
+   * Check whether a coupon can be redeemed (`POST /validation`). Resolves when
+   * redeemable; throws an `EmporixError` otherwise (no response body).
+   */
+  async validateCoupon(code, redemption, auth2 = SERVICE12) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}/validation`,
+      auth: auth2,
+      body: redemption
+    });
+  }
+  /** List a coupon's redemptions by criteria. */
+  async listRedemptions(code, query = {}, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Redeem a coupon by creating a redemption (`POST`, HTTP 201). Returns the resource location. */
+  async redeemCoupon(code, redemption, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions`,
+      auth: auth2,
+      body: redemption
+    });
+  }
+  /** Retrieve one redemption by id. */
+  async getRedemption(code, id, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /** Delete a redemption by id. */
+  async deleteRedemption(code, id, auth2 = SERVICE12) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/coupons/${encodeURIComponent(code)}/redemptions/${encodeURIComponent(id)}`,
+      auth: auth2
+    });
+  }
+  /** Retrieve a customer's referral coupon (resolves to an empty body when none exists). */
+  async getReferralCoupon(customerNumber, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/referral-coupons/${encodeURIComponent(customerNumber)}`,
+      auth: auth2
+    });
+  }
+  /** Create a referral coupon code for a customer (no request body). */
+  async createReferralCoupon(customerNumber, auth2 = SERVICE12) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/referral-coupons/${encodeURIComponent(customerNumber)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/reward-points.ts
+var SERVICE13 = { kind: "service" };
+var RewardPointsService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  /** Base without tenant (customer / public / batch endpoints). */
+  base() {
+    return `/reward-points`;
+  }
+  /** Tenant-scoped base (redeem options only). */
+  tenantBase() {
+    return `/reward-points/${this.ctx.tenant}`;
+  }
+  // --- Admin: customer points management (service token) ---
+  /** Batch summary across all customers. */
+  async listAllSummaries(query = {}, auth2 = SERVICE13) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/summaryBatch`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one customer's reward-points balance. */
+  async getCustomerPoints(customerId, auth2 = SERVICE13) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/customer/${encodeURIComponent(customerId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a reward-points entry for a customer. */
+  async createCustomerPoints(customerId, input, auth2 = SERVICE13) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/customer/${encodeURIComponent(customerId)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Delete a customer's reward points. */
+  async deleteCustomerPoints(customerId, auth2 = SERVICE13) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/customer/${encodeURIComponent(customerId)}`,
+      auth: auth2
+    });
+  }
+  /** Retrieve a reward-points summary for one customer. */
+  async getCustomerSummary(customerId, auth2 = SERVICE13) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/customer/${encodeURIComponent(customerId)}/summary`,
+      auth: auth2
+    });
+  }
+  /** Add reward points for a customer. */
+  async addPoints(customerId, input, auth2 = SERVICE13) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/customer/${encodeURIComponent(customerId)}/addPoints`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Redeem a customer's reward points (on behalf). */
+  async redeemPoints(customerId, input, auth2 = SERVICE13) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/customer/${encodeURIComponent(customerId)}/redeemPoints`,
+      auth: auth2,
+      body: input
+    });
+  }
+  // --- Storefront: the signed-in customer's own points (customer token required) ---
+  /** The signed-in customer's reward-points balance. Requires a customer `auth`. */
+  async getMyPoints(auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/public/customer`,
+      auth: auth2
+    });
+  }
+  /** The signed-in customer's reward-points summary. Requires a customer `auth`. */
+  async getMySummary(auth2) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/public/customer/summary`,
+      auth: auth2
+    });
+  }
+  /**
+   * Redeem the signed-in customer's points for a coupon code. Requires a
+   * customer `auth`. Returns the issued coupon `{ code }`.
+   */
+  async redeemMyPoints(input, auth2) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/public/customer/redeem`,
+      auth: auth2,
+      body: input
+    });
+  }
+  // --- 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 = SERVICE13) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.tenantBase()}/redeemOptions`,
+      auth: auth2
+    });
+  }
+  /** Create a redeem option. Returns the updated options list. */
+  async createRedeemOption(input, auth2 = SERVICE13) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.tenantBase()}/redeemOptions`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Update a redeem option by id. Resolves once accepted (no response body). */
+  async updateRedeemOption(redeemOptionId, input, auth2 = SERVICE13) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.tenantBase()}/redeemOptions/${encodeURIComponent(redeemOptionId)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Delete a redeem option by id. */
+  async deleteRedeemOption(redeemOptionId, auth2 = SERVICE13) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.tenantBase()}/redeemOptions/${encodeURIComponent(redeemOptionId)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/brand.ts
+var SERVICE14 = { kind: "service" };
+var BrandService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/brand/brands`;
+  }
+  /** List all brands. */
+  async listBrands(query = {}, auth2 = SERVICE14) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one brand by id. */
+  async getBrand(brandId, auth2 = SERVICE14) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${encodeURIComponent(brandId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a brand. */
+  async createBrand(input, auth2 = SERVICE14) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(),
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Replace a brand by id. */
+  async updateBrand(brandId, input, auth2 = SERVICE14) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${encodeURIComponent(brandId)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Partially update a brand by id. */
+  async patchBrand(brandId, patch, auth2 = SERVICE14) {
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/${encodeURIComponent(brandId)}`,
+      auth: auth2,
+      body: patch
+    });
+  }
+  /** Delete a brand by id. */
+  async deleteBrand(brandId, auth2 = SERVICE14) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${encodeURIComponent(brandId)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/label.ts
+var SERVICE15 = { kind: "service" };
+var LabelService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/label/labels`;
+  }
+  /** List all labels. */
+  async listLabels(query = {}, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one label by id. */
+  async getLabel(labelId, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${encodeURIComponent(labelId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a label. */
+  async createLabel(input, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(),
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Replace a label by id. */
+  async updateLabel(labelId, input, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${encodeURIComponent(labelId)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Partially update a label by id. */
+  async patchLabel(labelId, patch, auth2 = SERVICE15) {
+    return this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/${encodeURIComponent(labelId)}`,
+      auth: auth2,
+      body: patch
+    });
+  }
+  /** Delete a label by id. */
+  async deleteLabel(labelId, auth2 = SERVICE15) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${encodeURIComponent(labelId)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/country.ts
+var SERVICE16 = { kind: "service" };
+var CountryService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/country/${this.ctx.tenant}`;
+  }
+  /** List all countries. */
+  async listCountries(query = {}, auth2 = SERVICE16) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/countries`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one country by code. */
+  async getCountry(countryCode, auth2 = SERVICE16) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/countries/${encodeURIComponent(countryCode)}`,
+      auth: auth2
+    });
+  }
+  /** Partially update a country by code. Resolves once accepted (no response body). */
+  async patchCountry(countryCode, patch, auth2 = SERVICE16) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/countries/${encodeURIComponent(countryCode)}`,
+      auth: auth2,
+      body: patch
+    });
+  }
+  /** List all regions. */
+  async listRegions(query = {}, auth2 = SERVICE16) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/regions`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one region by code. */
+  async getRegion(regionCode, auth2 = SERVICE16) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/regions/${encodeURIComponent(regionCode)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/currency.ts
+var SERVICE17 = { kind: "service" };
+var CurrencyService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/currency/${this.ctx.tenant}`;
+  }
+  // --- Currencies ---
+  /** List all currencies. */
+  async listCurrencies(query = {}, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/currencies`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one currency by code. */
+  async getCurrency(code, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/currencies/${encodeURIComponent(code)}`,
+      auth: auth2
+    });
+  }
+  /** Create a currency. */
+  async createCurrency(input, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/currencies`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Update a currency by code. */
+  async updateCurrency(code, input, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/currencies/${encodeURIComponent(code)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Delete a currency by code. */
+  async deleteCurrency(code, auth2 = SERVICE17) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/currencies/${encodeURIComponent(code)}`,
+      auth: auth2
+    });
+  }
+  // --- Exchange rates ---
+  /** List all exchange rates. */
+  async listExchangeRates(query = {}, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/exchanges`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one exchange rate by code. */
+  async getExchangeRate(code, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/exchanges/${encodeURIComponent(code)}`,
+      auth: auth2
+    });
+  }
+  /** Create an exchange rate. */
+  async createExchangeRate(input, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/exchanges`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Update an exchange rate by code. */
+  async updateExchangeRate(code, input, auth2 = SERVICE17) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/exchanges/${encodeURIComponent(code)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Delete an exchange rate by code. */
+  async deleteExchangeRate(code, auth2 = SERVICE17) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/exchanges/${encodeURIComponent(code)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/shipping.ts
+var SERVICE18 = { kind: "service" };
+var ShippingService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/shipping/${this.ctx.tenant}`;
+  }
+  siteBase(site) {
+    return `${this.base()}/${encodeURIComponent(site)}`;
+  }
+  // --- Sites ---
+  /** Find shipping-related sites by postal code (`POST /findSite`). */
+  async findSites(input, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/findSite`,
+      auth: auth2,
+      body: input
+    });
+  }
+  // --- Zones ---
+  /** List shipping zones for a site. */
+  async listZones(site, query = {}, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/zones`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one shipping zone. */
+  async getZone(site, zoneId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a shipping zone. */
+  async createZone(site, zone, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.siteBase(site)}/zones`,
+      auth: auth2,
+      body: zone
+    });
+  }
+  /** Replace a shipping zone. */
+  async updateZone(site, zoneId, zone, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
+      auth: auth2,
+      body: zone
+    });
+  }
+  /** Partially update a shipping zone. */
+  async patchZone(site, zoneId, patch, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
+      auth: auth2,
+      body: patch
+    });
+  }
+  /** Delete a shipping zone. */
+  async deleteZone(site, zoneId, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}`,
+      auth: auth2
+    });
+  }
+  // --- Methods (per zone) ---
+  /** List shipping methods of a zone. */
+  async listMethods(site, zoneId, query = {}, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one shipping method. */
+  async getMethod(site, zoneId, methodId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a shipping method in a zone. */
+  async createMethod(site, zoneId, method, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods`,
+      auth: auth2,
+      body: method
+    });
+  }
+  /** Replace a shipping method. */
+  async updateMethod(site, zoneId, methodId, method, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
+      auth: auth2,
+      body: method
+    });
+  }
+  /** Partially update a shipping method. */
+  async patchMethod(site, zoneId, methodId, patch, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
+      auth: auth2,
+      body: patch
+    });
+  }
+  /** Delete a shipping method. */
+  async deleteMethod(site, zoneId, methodId, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.siteBase(site)}/zones/${encodeURIComponent(zoneId)}/methods/${encodeURIComponent(methodId)}`,
+      auth: auth2
+    });
+  }
+  // --- Cost / quote ---
+  /** Calculate the final shipping cost (`POST /quote`). */
+  async quote(site, input, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.siteBase(site)}/quote`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Calculate the minimum shipping cost (`POST /quote/minimum`). */
+  async quoteMinimum(site, input, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.siteBase(site)}/quote/minimum`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Calculate the shipping cost for a given slot (`POST /quote/slot`). */
+  async quoteSlot(site, input, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.siteBase(site)}/quote/slot`,
+      auth: auth2,
+      body: input
+    });
+  }
+  // --- Groups ---
+  /** List shipping groups for a site. */
+  async listGroups(site, query = {}, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/groups`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one shipping group. */
+  async getGroup(site, groupId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/groups/${encodeURIComponent(groupId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a shipping group. */
+  async createGroup(site, group, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.siteBase(site)}/groups`,
+      auth: auth2,
+      body: group
+    });
+  }
+  /** Replace a shipping group. */
+  async updateGroup(site, groupId, group, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.siteBase(site)}/groups/${encodeURIComponent(groupId)}`,
+      auth: auth2,
+      body: group
+    });
+  }
+  /** Delete a shipping group. */
+  async deleteGroup(site, groupId, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.siteBase(site)}/groups/${encodeURIComponent(groupId)}`,
+      auth: auth2
+    });
+  }
+  // --- Customer-group relations ---
+  /** List customer-group relations for a site. */
+  async listCgRelations(site, query = {}, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/cgrelations`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve a customer's customer-group relations. */
+  async getCgRelations(site, customerId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.siteBase(site)}/cgrelations/${encodeURIComponent(customerId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a customer-group relation. */
+  async createCgRelation(site, relation, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.siteBase(site)}/cgrelations`,
+      auth: auth2,
+      body: relation
+    });
+  }
+  /** Update a customer's customer-group relations. */
+  async updateCgRelations(site, customerId, relation, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.siteBase(site)}/cgrelations/${encodeURIComponent(customerId)}`,
+      auth: auth2,
+      body: relation
+    });
+  }
+  /** Delete a customer's customer-group relation. */
+  async deleteCgRelation(site, customerId, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.siteBase(site)}/cgrelations/${encodeURIComponent(customerId)}`,
+      auth: auth2
+    });
+  }
+  // --- Phase 2: delivery windows ---
+  /** Retrieve delivery windows for a delivery area + cart. */
+  async getAreaDeliveryWindows(deliveryAreaId, cartId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/areaDeliveryTimes/${encodeURIComponent(deliveryAreaId)}/${encodeURIComponent(cartId)}`,
+      auth: auth2
+    });
+  }
+  /** Retrieve delivery windows for a cart. */
+  async getCartDeliveryWindows(cartId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/actualDeliveryWindows/${encodeURIComponent(cartId)}`,
+      auth: auth2
+    });
+  }
+  /** Increment the delivery-window counter. */
+  async incrementDeliveryWindowCounter(input, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/actualDeliveryWindows/incrementCounter`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Validate a delivery window. Resolves when valid; throws otherwise. */
+  async validateDeliveryWindow(input, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/deliveryWindowValidation`,
+      auth: auth2,
+      body: input
+    });
+  }
+  // --- Phase 2: delivery times ---
+  /** List all delivery times. */
+  async listDeliveryTimes(query = {}, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/delivery-times`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one delivery time. */
+  async getDeliveryTime(deliveryTimeId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a delivery time. */
+  async createDeliveryTime(input, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/delivery-times`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Create multiple delivery times (`POST /delivery-times/bulk`). */
+  async createDeliveryTimesBulk(inputs, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/delivery-times/bulk`,
+      auth: auth2,
+      body: inputs
+    });
+  }
+  /** Replace a delivery time. */
+  async updateDeliveryTime(deliveryTimeId, input, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Partially update a delivery time (JSON-Patch op array). */
+  async patchDeliveryTime(deliveryTimeId, ops, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
+      auth: auth2,
+      body: ops
+    });
+  }
+  /** Delete a delivery time. */
+  async deleteDeliveryTime(deliveryTimeId, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}`,
+      auth: auth2
+    });
+  }
+  // --- Phase 2: delivery time slots ---
+  /** List slots of a delivery time. */
+  async listSlots(deliveryTimeId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots`,
+      auth: auth2
+    });
+  }
+  /** Retrieve one slot. */
+  async getSlot(deliveryTimeId, slotId, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a slot in a delivery time. */
+  async createSlot(deliveryTimeId, input, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Replace a slot. */
+  async updateSlot(deliveryTimeId, slotId, input, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Partially update a slot (JSON-Patch op array). */
+  async patchSlot(deliveryTimeId, slotId, ops, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
+      auth: auth2,
+      body: ops
+    });
+  }
+  /** Delete a slot. */
+  async deleteSlot(deliveryTimeId, slotId, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots/${encodeURIComponent(slotId)}`,
+      auth: auth2
+    });
+  }
+  /** Delete all slots of a delivery time. */
+  async deleteAllSlots(deliveryTimeId, auth2 = SERVICE18) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/delivery-times/${encodeURIComponent(deliveryTimeId)}/slots`,
+      auth: auth2
+    });
+  }
+  // --- Phase 2: delivery cycles ---
+  /** Generate a delivery cycle (`POST /delivery-cycles/generate`). Returns the cycle id. */
+  async generateDeliveryCycle(input, auth2 = SERVICE18) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/delivery-cycles/generate`,
+      auth: auth2,
+      body: input
+    });
+  }
+};
+
+// src/services/returns.ts
+var SERVICE19 = { kind: "service" };
+var ReturnsService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/return/${this.ctx.tenant}/returns`;
+  }
+  /** List returns (paged; supports `pageSize`/`pageNumber`/`sort`/`q`). */
+  async listReturns(query = {}, auth2 = SERVICE19) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve one return by id. */
+  async getReturn(returnId, auth2 = SERVICE19) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${encodeURIComponent(returnId)}`,
+      auth: auth2
+    });
+  }
+  /** Create a return. Returns the created `{ id }`. */
+  async createReturn(input, auth2 = SERVICE19) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(),
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Replace a return by id (`PUT`). */
+  async updateReturn(returnId, input, auth2 = SERVICE19) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${encodeURIComponent(returnId)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Partially update a return by id (`PATCH`, JSON-Patch op-array). */
+  async patchReturn(returnId, ops, auth2 = SERVICE19) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/${encodeURIComponent(returnId)}`,
+      auth: auth2,
+      body: ops
+    });
+  }
+  /** Delete a return by id. */
+  async deleteReturn(returnId, auth2 = SERVICE19) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${encodeURIComponent(returnId)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/sepa-export.ts
+var SERVICE20 = { kind: "service" };
+var SepaExportService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/sepa-export/${this.ctx.tenant}`;
+  }
+  /** Retrieve a SEPA export file by id. Returns the raw file content (text). */
+  async getFile(fileId, auth2 = SERVICE20) {
+    const path = `${this.base()}/files/${encodeURIComponent(fileId)}`;
+    const res = await this.ctx.http.requestRaw({ method: "GET", path, auth: auth2 });
+    if (!res.ok) {
+      const errBody = await res.text().catch(() => void 0);
+      throw errorFromResponse(res.status, `GET ${path} \u2192 ${res.status}`, errBody);
+    }
+    return res.text();
+  }
+  /** List export jobs. */
+  async listJobs(query = {}, auth2 = SERVICE20) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/jobs`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Create an export job. */
+  async createJob(input, auth2 = SERVICE20) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/jobs`,
+      auth: auth2,
+      body: input
+    });
+  }
+};
+
+// src/services/indexing.ts
+var SERVICE21 = { kind: "service" };
+var IndexingService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/indexing/${this.ctx.tenant}`;
+  }
+  /** List indexing configurations. */
+  async listConfigurations(auth2 = SERVICE21) {
+    return this.ctx.http.request({ method: "GET", path: `${this.base()}/configurations`, auth: auth2 });
+  }
+  /** Get a configuration by provider name. */
+  async getConfiguration(provider, auth2 = SERVICE21) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/configurations/${encodeURIComponent(provider)}`,
+      auth: auth2
+    });
+  }
+  /** Create a configuration. */
+  async createConfiguration(input, auth2 = SERVICE21) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/configurations`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Update a configuration by provider name. */
+  async updateConfiguration(provider, input, auth2 = SERVICE21) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/configurations/${encodeURIComponent(provider)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Delete a configuration by provider name. */
+  async deleteConfiguration(provider, auth2 = SERVICE21) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/configurations/${encodeURIComponent(provider)}`,
+      auth: auth2
+    });
+  }
+  /** List public indexing configurations. */
+  async listPublicConfigurations(auth2 = SERVICE21) {
+    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 = SERVICE21) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/public/configurations/${encodeURIComponent(provider)}`,
+      auth: auth2
+    });
+  }
+  /** Trigger a reindex. */
+  async reindex(input, auth2 = SERVICE21) {
+    await this.ctx.http.request({ method: "POST", path: `${this.base()}/reindex`, auth: auth2, body: input });
+  }
+};
+
+// src/services/unit-handling.ts
+var SERVICE22 = { kind: "service" };
+var UnitHandlingService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/unit-handling/${this.ctx.tenant}`;
+  }
+  /** Find units (filter/sort/page). */
+  async listUnits(query = {}, auth2 = SERVICE22) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/units`,
+      auth: auth2,
+      ...Object.keys(query).length ? { query } : {}
+    });
+  }
+  /** Retrieve a unit by code. */
+  async getUnit(unitCode, auth2 = SERVICE22) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/units/${encodeURIComponent(unitCode)}`,
+      auth: auth2
+    });
+  }
+  /** Add a new unit. */
+  async createUnit(input, auth2 = SERVICE22) {
+    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 = SERVICE22) {
+    await this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/units/${encodeURIComponent(unitCode)}`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Delete a unit by code. */
+  async deleteUnit(unitCode, auth2 = SERVICE22) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/units/${encodeURIComponent(unitCode)}`,
+      auth: auth2
+    });
+  }
+  /** Delete multiple units by code (bulk). The codes are sent as the request body. */
+  async deleteUnits(codes, auth2 = SERVICE22) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/units`,
+      auth: auth2,
+      body: codes
+    });
+  }
+  /** Fetch a conversion factor (`PUT /units/conversion-factor-commands`). */
+  async getConversionFactor(input, auth2 = SERVICE22) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/units/conversion-factor-commands`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** Convert a value between units (`PUT /units/convert-unit-commands`). */
+  async convertUnit(input, auth2 = SERVICE22) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/units/convert-unit-commands`,
+      auth: auth2,
+      body: input
+    });
+  }
+  /** List all unit types. */
+  async listUnitTypes(auth2 = SERVICE22) {
+    return this.ctx.http.request({ method: "GET", path: `${this.base()}/types`, auth: auth2 });
+  }
+};
+
 // package.json
-var version = "2.2.0";
+var version = "2.4.0";
 
 // src/version.ts
 var SDK_VERSION = version;
@@ -2413,6 +4535,25 @@ var EmporixClient = class {
   availability;
   tenantConfig;
   clientConfig;
+  shoppingLists;
+  ragIndexer;
+  sequentialIds;
+  fees;
+  webhooks;
+  schemas;
+  ai;
+  taxes;
+  coupons;
+  rewardPoints;
+  brands;
+  labels;
+  countries;
+  currencies;
+  shipping;
+  returns;
+  sepaExport;
+  indexing;
+  units;
   /** The validated tenant this client is bound to. */
   tenant;
   /**
@@ -2485,6 +4626,25 @@ var EmporixClient = class {
     this.availability = new AvailabilityService(mk("availability"));
     this.tenantConfig = new TenantConfigService(mk("configuration"));
     this.clientConfig = new ClientConfigService(mk("configuration"));
+    this.shoppingLists = new ShoppingListService(mk("shopping-list"));
+    this.ragIndexer = new RagIndexerService(mk("ai-rag-indexer"));
+    this.sequentialIds = new SequentialIdService(mk("sequential-id"));
+    this.fees = new FeeService(mk("fee"));
+    this.webhooks = new WebhookService(mk("webhook"));
+    this.schemas = new SchemaService(mk("schema"));
+    this.ai = new AiService(mk("ai"));
+    this.taxes = new TaxService(mk("tax"));
+    this.coupons = new CouponService(mk("coupon"));
+    this.rewardPoints = new RewardPointsService(mk("reward-points"));
+    this.brands = new BrandService(mk("brand"));
+    this.labels = new LabelService(mk("label"));
+    this.countries = new CountryService(mk("country"));
+    this.currencies = new CurrencyService(mk("currency"));
+    this.shipping = new ShippingService(mk("shipping"));
+    this.returns = new ReturnsService(mk("returns"));
+    this.sepaExport = new SepaExportService(mk("sepa-export"));
+    this.indexing = new IndexingService(mk("indexing"));
+    this.units = new UnitHandlingService(mk("unit-handling"));
   }
   /** Sets the runtime log level globally or for one service. */
   setLogLevel(level, opts = {}) {
@@ -2496,13 +4656,18 @@ var EmporixClient = class {
   }
 };
 
+exports.AiService = AiService;
 exports.AvailabilityService = AvailabilityService;
+exports.BrandService = BrandService;
 exports.CartService = CartService;
 exports.CategoryService = CategoryService;
 exports.CheckoutService = CheckoutService;
 exports.ClientConfigService = ClientConfigService;
 exports.CompaniesService = CompaniesService;
 exports.ContactsService = ContactsService;
+exports.CountryService = CountryService;
+exports.CouponService = CouponService;
+exports.CurrencyService = CurrencyService;
 exports.CustomerGroupsService = CustomerGroupsService;
 exports.CustomerService = CustomerService;
 exports.DEFAULT_HOST = DEFAULT_HOST;
@@ -2515,8 +4680,11 @@ exports.EmporixInsufficientScopeError = EmporixInsufficientScopeError;
 exports.EmporixNotFoundError = EmporixNotFoundError;
 exports.EmporixServerError = EmporixServerError;
 exports.EmporixValidationError = EmporixValidationError;
+exports.FeeService = FeeService;
 exports.HttpClient = HttpClient;
+exports.IndexingService = IndexingService;
 exports.LEVEL = LEVEL;
+exports.LabelService = LabelService;
 exports.LevelResolver = LevelResolver;
 exports.LocationsService = LocationsService;
 exports.MediaService = MediaService;
@@ -2524,11 +4692,22 @@ exports.OrdersService = OrdersService;
 exports.PaymentGatewayService = PaymentGatewayService;
 exports.PriceService = PriceService;
 exports.ProductService = ProductService;
+exports.RagIndexerService = RagIndexerService;
+exports.ReturnsService = ReturnsService;
+exports.RewardPointsService = RewardPointsService;
 exports.SalesOrdersService = SalesOrdersService;
+exports.SchemaService = SchemaService;
 exports.SegmentService = SegmentService;
+exports.SepaExportService = SepaExportService;
+exports.SequentialIdService = SequentialIdService;
 exports.SessionContextService = SessionContextService;
+exports.ShippingService = ShippingService;
+exports.ShoppingListService = ShoppingListService;
 exports.SiteService = SiteService;
+exports.TaxService = TaxService;
 exports.TenantConfigService = TenantConfigService;
+exports.UnitHandlingService = UnitHandlingService;
+exports.WebhookService = WebhookService;
 exports.auth = auth;
 exports.createConsoleLogger = createConsoleLogger;
 exports.createNoopLogger = createNoopLogger;