@viu/emporix-sdk 3.5.0 → 4.0.0

package/dist/index.cjs

@@ -1242,7 +1242,7 @@ var HttpClient = class {
 };
 
 // package.json
-var version = "3.5.0";
+var version = "4.0.0";
 
 // src/version.ts
 var SDK_VERSION = version;
@@ -1872,6 +1872,20 @@ var ProductService = class {
   /**
    * Partially updates a product (`PATCH /products/{productId}`). Default auth:
    * service. Use {@link replace} for a full replace (PUT).
+   *
+   * Omitted fields stay as they are. **Mixins merge rather than replace**, and
+   * the corollary catches people out: there is no way to delete a mixin here.
+   * - a mixin name you omit stays on the product;
+   * - fields you send inside a mixin are merged recursively, and fields you
+   *   omit inside that mixin keep their values;
+   * - `null` does **not** delete a mixin — it stores `null` as its value.
+   *
+   * To actually remove one, read the product and send it back through
+   * {@link replace} with `partial: false`, leaving the mixin out of both
+   * `mixins` and `metadata.mixins`.
+   *
+   * Despite the HTTP verb this is **not** a JSON-Patch endpoint: an op-array of
+   * `{ op, path, value }` is rejected. Send a partial product document.
    */
   async update(productId, input, options = {}, auth2 = SERVICE) {
     const query = {
@@ -1891,6 +1905,12 @@ var ProductService = class {
    * 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.
+   *
+   * With `partial: false` (the default) the body must be the **complete**
+   * product document, and any mixin name missing from it is removed — which is
+   * what makes this the only way to delete a mixin, since {@link update} merges
+   * them. The flip side is that a body you did not build from a fresh read will
+   * silently drop mixins.
    */
   async replace(productId, input, options = {}, auth2 = SERVICE) {
     const query = {
@@ -3453,6 +3473,35 @@ var MediaService = class {
       body: input.body
     });
   }
+  /**
+   * Partially update an asset with an RFC-6902 JSON-Patch op-array
+   * (`PATCH /assets/{id}`, HTTP 204 — nothing is returned).
+   *
+   * This is the way to change one field without resending the whole asset, and
+   * the only way to touch a `BLOB` asset's metadata **without re-uploading the
+   * file** — {@link update} in `blob` mode always replaces the bytes.
+   *
+   * Append to an array with a path ending in `/-`, which preserves the existing
+   * entries:
+   *
+   * ```ts
+   * await client.media.patch(assetId, [
+   *   { op: "add", path: "/refIds/-", value: { id: "product1", type: "PRODUCT" } },
+   * ]);
+   * ```
+   *
+   * `type` and `access` are immutable here too, as with {@link update}. Only
+   * `add`, `remove` and `replace` are accepted, and optimistic locking still
+   * applies — a stale `metadata.version` gets a 409.
+   */
+  async patch(assetId, ops, auth2 = SERVICE5) {
+    await this.ctx.http.request({
+      method: "PATCH",
+      path: `${this.base()}/${encodeURIComponent(assetId)}`,
+      auth: auth2,
+      body: ops
+    });
+  }
   /** Remove an asset. */
   async remove(assetId, auth2 = SERVICE5) {
     await this.ctx.http.request({
@@ -3616,7 +3665,12 @@ var SegmentService = class {
   base() {
     return `/customer-segment/${this.ctx.tenant}/segments`;
   }
-  /** Lists segments the caller belongs to (with `segment_read_own`). */
+  /**
+   * Lists segments via the generic `GET /segments` (with `segment_read_own`).
+   * Its documentation does not say whether segments inherited through IAM
+   * groups are included — for "which segments is this customer in", use
+   * {@link listMine}, which is documented to include them.
+   */
   async list(query = {}, auth2) {
     const q = {};
     setIfDefined(q, "q", query.q);
@@ -3629,6 +3683,26 @@ var SegmentService = class {
       ...Object.keys(q).length ? { query: q } : {}
     });
   }
+  /**
+   * The authenticated customer's **active** segments (`GET /segments/me`,
+   * `segment_read_own`): assigned directly, and inherited through the
+   * customer's IAM groups — groups not bound to a legal entity, plus groups
+   * bound to the customer's *current* legal entity. Switching the active company
+   * can therefore change the result.
+   */
+  async listMine(query = {}, auth2) {
+    const q = {};
+    setIfDefined(q, "q", query.q);
+    setIfDefined(q, "pageNumber", query.pageNumber);
+    setIfDefined(q, "pageSize", query.pageSize);
+    setIfDefined(q, "sort", query.sort);
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/me`,
+      auth: requireCustomer(auth2),
+      ...Object.keys(q).length ? { query: q } : {}
+    });
+  }
   /** Fetches a single segment by id. */
   async get(segmentId, auth2) {
     return this.ctx.http.request({
@@ -3880,6 +3954,58 @@ var SegmentService = class {
       body
     })
   };
+  /**
+   * IAM group→segment assignments (`segment_read` / `segment_manage`). Customers
+   * inherit a segment through their groups, on top of direct assignment — see
+   * {@link listMine}. Only groups with `userType: "CUSTOMER"` can be assigned;
+   * anything else is a `400`. Default auth: service.
+   */
+  groups = {
+    list: async (segmentId, query = {}, authCtx = SERVICE6) => {
+      const q = {};
+      setIfDefined(q, "q", query.q);
+      setIfDefined(q, "pageNumber", query.pageNumber);
+      setIfDefined(q, "pageSize", query.pageSize);
+      setIfDefined(q, "sort", query.sort);
+      return this.ctx.http.request({
+        method: "GET",
+        path: `${this.base()}/${encodeURIComponent(segmentId)}/groups`,
+        auth: authCtx,
+        ...Object.keys(q).length ? { query: q } : {}
+      });
+    },
+    search: async (segmentId, query, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/${encodeURIComponent(segmentId)}/groups/search`,
+      auth: authCtx,
+      body: query
+    }),
+    get: async (segmentId, groupId, authCtx = SERVICE6) => this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${encodeURIComponent(segmentId)}/groups/${encodeURIComponent(groupId)}`,
+      auth: authCtx
+    }),
+    /**
+     * Upsert: `201` when the assignment is created, `204` when it is updated —
+     * **neither returns a body**, so this resolves to nothing. Fetch it with
+     * {@link get} if you need the stored assignment.
+     */
+    assign: async (segmentId, groupId, input = {}, authCtx = SERVICE6) => {
+      await this.ctx.http.request({
+        method: "PUT",
+        path: `${this.base()}/${encodeURIComponent(segmentId)}/groups/${encodeURIComponent(groupId)}`,
+        auth: authCtx,
+        body: input
+      });
+    },
+    remove: async (segmentId, groupId, authCtx = SERVICE6) => {
+      await this.ctx.http.request({
+        method: "DELETE",
+        path: `${this.base()}/${encodeURIComponent(segmentId)}/groups/${encodeURIComponent(groupId)}`,
+        auth: authCtx
+      });
+    }
+  };
   /** Item→segment assignments (`type` = PRODUCT | CATEGORY). Default auth: service. */
   items = {
     search: async (segmentId, query, authCtx = SERVICE6) => this.ctx.http.request({
@@ -6367,6 +6493,16 @@ var AnalyticsResource = class {
 
 // src/services/ai.ts
 var SERVICE17 = { kind: "service" };
+function assertChatOptions(opts, method) {
+  if (typeof opts === "object" && opts !== null && "kind" in opts) {
+    throw new Error(
+      `ai.${method}: the second argument is { sessionId? } since 4.0.0 \u2014 pass the auth context third`
+    );
+  }
+}
+function sessionHeader(opts) {
+  return opts.sessionId ? { headers: { "session-id": opts.sessionId } } : {};
+}
 var AiService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -6497,40 +6633,50 @@ var AiService = class {
   /**
    * Synchronous agent chat (`POST /agentic/chat`). Returns the response
    * ARRAY verbatim (the upstream contract is an array, not a single object).
+   *
+   * `opts.sessionId` is sent as the `session-id` header. It carries the
+   * conversation — continuity needs it plus `enabledMemory` on the agent — and
+   * it is how a chat reaches an attachment: pass the `sessionId` the upload or
+   * reuse returned, and list the file under `input.attachments`.
    */
-  async chat(input, auth2 = SERVICE17) {
+  async chat(input, opts = {}, auth2 = SERVICE17) {
+    assertChatOptions(opts, "chat");
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/chat`,
       auth: auth2,
-      body: input
+      body: input,
+      ...sessionHeader(opts)
     });
   }
   /**
    * Fire-and-forget agent chat (`POST /agentic/chat-async`, HTTP 201).
-   * Returns the job-id ARRAY verbatim.
+   * Returns the job-id ARRAY verbatim. `opts` as for {@link chat}.
    */
-  async chatAsync(input, auth2 = SERVICE17) {
+  async chatAsync(input, opts = {}, auth2 = SERVICE17) {
+    assertChatOptions(opts, "chatAsync");
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/agentic/chat-async`,
       auth: auth2,
-      body: input
+      body: input,
+      ...sessionHeader(opts)
     });
   }
   /**
    * Streaming agent chat (`POST /agentic/chat-stream`, `text/event-stream`).
    * Yields each SSE `data` payload verbatim — the upstream contract types the
    * stream body as an opaque string, so chunks are raw strings, not parsed
-   * objects. Consume with `for await`.
+   * objects. Consume with `for await`. `opts` as for {@link chat}.
    */
   async *chatStream(input, opts = {}, auth2 = SERVICE17) {
+    assertChatOptions(opts, "chatStream");
     const events = this.ctx.http.requestStream({
       method: "POST",
       path: `${this.base()}/agentic/chat-stream`,
       auth: auth2,
       body: input,
-      ...opts.sessionId ? { headers: { "session-id": opts.sessionId } } : {}
+      ...sessionHeader(opts)
     });
     for await (const ev of events) yield ev.data;
   }
@@ -6573,6 +6719,10 @@ var AiService = class {
    * (`POST /agentic/{agentId}/attachments`, multipart, HTTP 201). The response
    * `sessionId` must be threaded into subsequent chat calls to bind the file.
    * Pass `opts.sessionId` to attach to an existing session.
+   *
+   * The endpoint takes exactly one of `attachment` or `attachmentId` — both or
+   * neither is a `400`. This method always sends the file; to point a second
+   * agent at a file already in the session, use {@link reuseAttachment}.
    */
   async uploadAttachment(agentId, attachment, opts = {}, auth2 = SERVICE17) {
     const form = new FormData();
@@ -6585,6 +6735,34 @@ var AiService = class {
       ...opts.sessionId ? { headers: { "session-id": opts.sessionId } } : {}
     });
   }
+  /**
+   * Assign an existing media asset to an agent as a chat attachment
+   * (`POST /agentic/{agentId}/attachments` with the `attachmentId` form field,
+   * HTTP 200). Resolves to the attachment `id` and the `sessionId` to send on
+   * the following chat calls.
+   *
+   * Use it to hand a second agent the same file instead of uploading it twice.
+   * Pass `opts.sessionId` to attach to an existing chat session; without it the
+   * service opens a new one and returns its id — thread that into the chat, or
+   * the agent never sees the file. With `ai.agentexecution_manage` the asset may
+   * be any media asset, not only one uploaded to this session.
+   *
+   * ```ts
+   * const { id, sessionId } = await client.ai.uploadAttachment("agent-a", file);
+   * await client.ai.reuseAttachment("agent-b", id!, { sessionId: sessionId! });
+   * ```
+   */
+  async reuseAttachment(agentId, attachmentId, opts = {}, auth2 = SERVICE17) {
+    const form = new FormData();
+    form.append("attachmentId", attachmentId);
+    return this.ctx.http.request({
+      method: "POST",
+      path: `${this.base()}/agentic/${encodeURIComponent(agentId)}/attachments`,
+      auth: auth2,
+      body: form,
+      ...opts.sessionId ? { headers: { "session-id": opts.sessionId } } : {}
+    });
+  }
   /** Export agents + components as a base64/checksum blob (`POST /agentic/agents/export`). */
   async exportAgents(body, auth2 = SERVICE17) {
     return this.ctx.http.request({
@@ -8125,6 +8303,23 @@ var ImportService = class {
       auth: auth2
     });
   }
+  /**
+   * The order in which a configuration's streams run, and the dependencies
+   * behind it. Read it here instead of deriving it from the stream definitions:
+   * mapping transformations add dependencies that no single stream shows, so a
+   * self-computed order can differ from the one used at run time.
+   *
+   * The result lists stream **names**, while {@link triggerRun}'s `streamIds`
+   * takes stream **ids** — map through {@link listStreams} before passing a
+   * subset back.
+   */
+  async getStreamOrder(configId, auth2 = SERVICE29) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/configs/${encodeURIComponent(configId)}/stream-order`,
+      auth: auth2
+    });
+  }
   /**
    * Fetch a configuration's schedule. Resolves to `null` when none is
    * configured — the service answers `204`, not `404`, so an absent schedule is
@@ -8189,6 +8384,9 @@ var ImportService = class {
    * integration scenario are indistinguishable in the history. Note the service
    * **rejects** an `origin` over 40 characters instead of shortening it.
    *
+   * `streamIds` runs a subset — see {@link ImportRunInput} for what is rejected,
+   * and note it takes ids where {@link getStreamOrder} reports names.
+   *
    * Not retried on a 5xx: a POST that timed out may already have queued a run.
    *
    * @example
@@ -8280,6 +8478,43 @@ var ImportService = class {
     });
     return toPage(wire, args);
   }
+  /**
+   * The rows behind a run's feed-quality counters: source rows that repeated a
+   * natural key (`kind: "REPEATED_KEY"`, counted as `duplicateKeys`) and child
+   * lines with no parent to attach to (`"UNRESOLVED_PARENT"`, counted as
+   * `unresolvedParents`). Neither is a failure, which is why these rows are not
+   * in {@link listRunErrors}.
+   *
+   * **A capped sample** — see {@link ImportRunDiagnostics} before reading
+   * `rows.length` as the size of the problem. `limit` defaults to 500 here
+   * (1–50 000); {@link downloadRunDiagnosticsCsv} defaults to 50 000.
+   */
+  async listRunDiagnostics(runId, query = {}, auth2 = SERVICE29) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/runs/${encodeURIComponent(runId)}/diagnostics`,
+      query: { ...query },
+      auth: auth2
+    });
+  }
+  /**
+   * The same rows as {@link listRunDiagnostics}, as CSV text for a spreadsheet
+   * or a ticket. Comment lines above the header record whether `limit` or the
+   * recording cap cut rows off, so the file keeps that context when shared on
+   * its own. `limit` defaults to 50 000 here, not 500.
+   *
+   * Every value is quoted, and a value starting with `=`, `+`, `-` or `@` is
+   * prefixed with an apostrophe so spreadsheet software does not evaluate source
+   * data as a formula. Strip it if you parse the file instead of opening it.
+   */
+  async downloadRunDiagnosticsCsv(runId, query = {}, auth2 = SERVICE29) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/runs/${encodeURIComponent(runId)}/diagnostics/csv`,
+      query: { ...query },
+      auth: auth2
+    });
+  }
   /** List the target types that hold imported records — the valid `type` values for {@link searchRecords}. */
   async listDataTypes(auth2 = SERVICE29) {
     return this.ctx.http.request({
@@ -8727,100 +8962,8 @@ var VendorService = class {
   }
 };
 
-// src/services/pick-pack.ts
-var SERVICE34 = { kind: "service" };
-var PickPackService = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  ctx;
-  static channel = "pick-pack";
-  base() {
-    return `/pick-pack/${this.ctx.tenant}`;
-  }
-  orderPath(orderId) {
-    return `${this.base()}/orders/${encodeURIComponent(orderId)}`;
-  }
-  /** List packlist orders. */
-  async listOrders(query = {}, auth2 = SERVICE34) {
-    return this.ctx.http.request({
-      method: "GET",
-      path: `${this.base()}/orders`,
-      auth: auth2,
-      ...Object.keys(query).length ? { query } : {}
-    });
-  }
-  /** Retrieve a packlist order by id. */
-  async getOrder(orderId, auth2 = SERVICE34) {
-    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 = SERVICE34) {
-    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 = SERVICE34) {
-    return this.ctx.http.request({ method: "POST", path: `${this.orderPath(orderId)}/finish`, auth: auth2 });
-  }
-  /** List order cycles (ids). */
-  async listOrderCycles(query = {}, auth2 = SERVICE34) {
-    return this.ctx.http.request({
-      method: "GET",
-      path: `${this.base()}/orderCycles`,
-      auth: auth2,
-      ...Object.keys(query).length ? { query } : {}
-    });
-  }
-  /** Add an assignee to an order. Returns an acknowledgement. */
-  async addAssignee(orderId, assignee, auth2 = SERVICE34) {
-    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 = SERVICE34) {
-    await this.ctx.http.request({
-      method: "DELETE",
-      path: `${this.orderPath(orderId)}/assignees/${encodeURIComponent(assigneeId)}`,
-      auth: auth2
-    });
-  }
-  /** Update packaging products for an order (`PUT`). Returns an acknowledgement. */
-  async updatePackaging(orderId, change, auth2 = SERVICE34) {
-    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 = SERVICE34) {
-    return this.ctx.http.request({ method: "POST", path: `${this.base()}/events`, auth: auth2, body: event });
-  }
-  /** List packing events. */
-  async listEvents(query = {}, auth2 = SERVICE34) {
-    return this.ctx.http.request({
-      method: "GET",
-      path: `${this.base()}/events`,
-      auth: auth2,
-      ...Object.keys(query).length ? { query } : {}
-    });
-  }
-  /** Trigger an order recalculation. Returns the created job's id. */
-  async triggerRecalculation(input, auth2 = SERVICE34) {
-    return this.ctx.http.request({
-      method: "POST",
-      path: `${this.base()}/jobs/recalculations`,
-      auth: auth2,
-      body: input
-    });
-  }
-  /** Retrieve a recalculation job by id. */
-  async getRecalculationJob(jobId, auth2 = SERVICE34) {
-    return this.ctx.http.request({
-      method: "GET",
-      path: `${this.base()}/jobs/recalculations/${encodeURIComponent(jobId)}`,
-      auth: auth2
-    });
-  }
-};
-
 // src/services/customer-admin.ts
-var SERVICE35 = { kind: "service" };
+var SERVICE34 = { kind: "service" };
 var CustomerAdminService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -8841,7 +8984,7 @@ var CustomerAdminService = class {
   }
   // --- Customers ---
   /** List customers. */
-  async listCustomers(query = {}, auth2 = SERVICE35) {
+  async listCustomers(query = {}, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "GET",
       path: this.base(),
@@ -8850,33 +8993,33 @@ var CustomerAdminService = class {
     });
   }
   /** Search customers (`POST /customers/search`). A built filter in `q` is resolved to a string. */
-  async searchCustomers(query, auth2 = SERVICE35) {
+  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 = SERVICE35) {
+  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 = SERVICE35) {
+  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 = SERVICE35) {
+  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 = SERVICE35) {
+  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 = SERVICE35) {
+  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 = SERVICE35) {
+  async listAddresses(customerNumber, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.customerPath(customerNumber)}/addresses`,
@@ -8884,11 +9027,11 @@ var CustomerAdminService = class {
     });
   }
   /** Retrieve one address. */
-  async getAddress(customerNumber, addressId, auth2 = SERVICE35) {
+  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 = SERVICE35) {
+  async addAddress(customerNumber, input, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.customerPath(customerNumber)}/addresses`,
@@ -8897,19 +9040,19 @@ var CustomerAdminService = class {
     });
   }
   /** Upsert an address by id (`PUT`). */
-  async upsertAddress(customerNumber, addressId, input, auth2 = SERVICE35) {
+  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 = SERVICE35) {
+  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 = SERVICE35) {
+  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 = SERVICE35) {
+  async addAddressTags(customerNumber, addressId, tags, auth2 = SERVICE34) {
     await this.ctx.http.request({
       method: "POST",
       path: `${this.addressPath(customerNumber, addressId)}/tags`,
@@ -8918,7 +9061,7 @@ var CustomerAdminService = class {
     });
   }
   /** Remove tags from an address (`?tags=` query). */
-  async removeAddressTags(customerNumber, addressId, tags, auth2 = SERVICE35) {
+  async removeAddressTags(customerNumber, addressId, tags, auth2 = SERVICE34) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.addressPath(customerNumber, addressId)}/tags`,
@@ -8932,7 +9075,7 @@ var CustomerAdminService = class {
    * `customer.import_read` scope. An unconfigured tenant answers with an empty
    * object rather than a 404.
    */
-  async getPasswordMigrationRetention(auth2 = SERVICE35) {
+  async getPasswordMigrationRetention(auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "GET",
       path: this.configPath(),
@@ -8945,7 +9088,7 @@ var CustomerAdminService = class {
    * `legacyAuth`** — that import is rejected without an active config. Re-POST with
    * an earlier `retentionEndDate` to shorten a running window.
    */
-  async configurePasswordMigrationRetention(input, auth2 = SERVICE35) {
+  async configurePasswordMigrationRetention(input, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "POST",
       path: this.configPath(),
@@ -8958,7 +9101,7 @@ var CustomerAdminService = class {
    * Intended for after the migration window: when the window ends, unmigrated
    * accounts need a password reset and their legacy credentials are cleared.
    */
-  async deletePasswordMigrationRetention(auth2 = SERVICE35) {
+  async deletePasswordMigrationRetention(auth2 = SERVICE34) {
     await this.ctx.http.request({ method: "DELETE", path: this.configPath(), auth: auth2 });
   }
   // --- Bulk import ---
@@ -8971,7 +9114,7 @@ var CustomerAdminService = class {
    * `account.legacyAuth`, and importing `legacyAuth` requires an active retention
    * config (see `configurePasswordMigrationRetention`).
    */
-  async importCustomers(input, auth2 = SERVICE35) {
+  async importCustomers(input, auth2 = SERVICE34) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/import`,
@@ -8982,7 +9125,7 @@ var CustomerAdminService = class {
 };
 
 // src/services/approval.ts
-var SERVICE36 = { kind: "service" };
+var SERVICE35 = { kind: "service" };
 var ApprovalService = class {
   constructor(ctx) {
     this.ctx = ctx;
@@ -8993,7 +9136,7 @@ var ApprovalService = class {
     return `/approval/${this.ctx.tenant}`;
   }
   /** List approvals (paged via `pageNumber`/`pageSize`/`sort`/`q`). Returns an array. */
-  async listApprovals(query = {}, auth2 = SERVICE36) {
+  async listApprovals(query = {}, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/approvals`,
@@ -9002,7 +9145,7 @@ var ApprovalService = class {
     });
   }
   /** Retrieve a single approval by id. */
-  async getApproval(approvalId, auth2 = SERVICE36) {
+  async getApproval(approvalId, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "GET",
       path: `${this.base()}/approvals/${encodeURIComponent(approvalId)}`,
@@ -9010,7 +9153,7 @@ var ApprovalService = class {
     });
   }
   /** Create an approval request (cart or quote). Returns the created `{ id }`. */
-  async createApproval(input, auth2 = SERVICE36) {
+  async createApproval(input, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/approvals`,
@@ -9019,7 +9162,7 @@ var ApprovalService = class {
     });
   }
   /** Approve/reject/amend an approval via a JSON-Patch op-array (`PATCH`). */
-  async updateApproval(approvalId, ops, auth2 = SERVICE36) {
+  async updateApproval(approvalId, ops, auth2 = SERVICE35) {
     await this.ctx.http.request({
       method: "PATCH",
       path: `${this.base()}/approvals/${encodeURIComponent(approvalId)}`,
@@ -9028,7 +9171,7 @@ var ApprovalService = class {
     });
   }
   /** Delete an approval by id. */
-  async deleteApproval(approvalId, auth2 = SERVICE36) {
+  async deleteApproval(approvalId, auth2 = SERVICE35) {
     await this.ctx.http.request({
       method: "DELETE",
       path: `${this.base()}/approvals/${encodeURIComponent(approvalId)}`,
@@ -9036,7 +9179,7 @@ var ApprovalService = class {
     });
   }
   /** Check whether an operation on a resource is permitted / needs approval. */
-  async checkPermitted(input, auth2 = SERVICE36) {
+  async checkPermitted(input, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/approval/permitted`,
@@ -9045,7 +9188,7 @@ var ApprovalService = class {
     });
   }
   /** Search for users eligible to approve a resource. Returns an array. */
-  async searchApprovers(input, auth2 = SERVICE36) {
+  async searchApprovers(input, auth2 = SERVICE35) {
     return this.ctx.http.request({
       method: "POST",
       path: `${this.base()}/search/users`,
@@ -9112,7 +9255,6 @@ var EmporixClient = class {
   units;
   catalogs;
   vendors;
-  pickPack;
   customerAdmin;
   approvals;
   /** The validated tenant this client is bound to. */
@@ -9187,7 +9329,6 @@ var EmporixClient = class {
     this.units = new UnitHandlingService(mk(UnitHandlingService.channel));
     this.catalogs = new CatalogService(mk(CatalogService.channel));
     this.vendors = new VendorService(mk(VendorService.channel));
-    this.pickPack = new PickPackService(mk(PickPackService.channel));
     this.customerAdmin = new CustomerAdminService(mk(CustomerAdminService.channel));
     this.approvals = new ApprovalService(mk(ApprovalService.channel));
   }
@@ -9302,7 +9443,6 @@ exports.LocationsService = LocationsService;
 exports.MediaService = MediaService;
 exports.OrdersService = OrdersService;
 exports.PaymentGatewayService = PaymentGatewayService;
-exports.PickPackService = PickPackService;
 exports.PriceService = PriceService;
 exports.ProductService = ProductService;
 exports.QuoteService = QuoteService;