@viu/emporix-sdk 2.1.0 → 2.3.0

package/dist/index.cjs

@@ -996,6 +996,46 @@ var ProductService = class {
     );
     return pages.flat();
   }
+  /**
+   * Bulk fetch by code. POSTs `/products/search` with `q="code:(c1,c2,…)"`,
+   * chunking when the list is larger than `options.chunkSize` (default 100).
+   * Duplicate codes are de-duplicated. Codes containing query-delimiter
+   * characters (`(`, `)`, `,`, whitespace, `"`) are dropped with a logged
+   * warning, because the Emporix `q` syntax uses them as delimiters and does
+   * not support escaping them in a plain IN-list. An empty list — or one with
+   * no safe codes — short-circuits with no HTTP call. **Order is not
+   * guaranteed** across chunks — re-index by `code` if order matters.
+   */
+  async searchByCodes(codes, options = {}, auth2 = ANON) {
+    const unique = [...new Set(codes)];
+    const unsafe = /[(),"\s]/;
+    const safe = unique.filter((c) => !unsafe.test(c));
+    const dropped = unique.filter((c) => unsafe.test(c));
+    if (dropped.length > 0) {
+      this.ctx.logger.warn(
+        "products.searchByCodes: dropped codes containing query-delimiter characters",
+        { dropped }
+      );
+    }
+    if (safe.length === 0) return [];
+    const chunkSize = options.chunkSize ?? 100;
+    const chunks = [];
+    for (let i = 0; i < safe.length; i += chunkSize) {
+      chunks.push(safe.slice(i, i + chunkSize));
+    }
+    const pages = await Promise.all(
+      chunks.map(
+        (chunk) => this.ctx.http.request({
+          method: "POST",
+          path: `/product/${this.ctx.tenant}/products/search`,
+          query: { pageSize: chunk.length },
+          auth: auth2,
+          body: { q: `code:(${chunk.join(",")})` }
+        })
+      )
+    );
+    return pages.flat();
+  }
   /**
    * Streams the VARIANT children of a PARENT_VARIANT product, page by page,
    * via the search query `productType:VARIANT parentVariantId:<id>`. Default
@@ -1880,12 +1920,12 @@ var SessionContextService = class {
    * update). Non-404 errors propagate.
    */
   async patch(input, authCtx = ANON5) {
-    let version = input.version;
-    if (version === void 0) {
+    let version2 = input.version;
+    if (version2 === void 0) {
       const current = await this.get(authCtx);
       if (current === null) return false;
-      version = current.metadata?.version;
-      if (version === void 0) {
+      version2 = current.metadata?.version;
+      if (version2 === void 0) {
         throw new Error(
           "SessionContextService.patch: no metadata.version in server response"
         );
@@ -1897,7 +1937,7 @@ var SessionContextService = class {
       path: `/session-context/${this.ctx.tenant}/me/context`,
       body: {
         ...fields,
-        metadata: { version }
+        metadata: { version: version2 }
       },
       auth: authCtx
     });
@@ -2232,8 +2272,963 @@ var AvailabilityService = class {
   }
 };
 
+// src/services/tenant-config.ts
+var SERVICE3 = { kind: "service" };
+var TenantConfigService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base() {
+    return `/configuration/${this.ctx.tenant}/configurations`;
+  }
+  /** List tenant configurations, optionally filtered by `keys`. */
+  async list(opts = {}, auth2 = SERVICE3) {
+    const query = opts.keys && opts.keys.length > 0 ? { keys: opts.keys.join(",") } : void 0;
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.base(),
+      auth: auth2,
+      ...query ? { query } : {}
+    });
+  }
+  /** Retrieve one tenant configuration by key. */
+  async get(key, auth2 = SERVICE3) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base()}/${encodeURIComponent(key)}`,
+      auth: auth2
+    });
+  }
+  /** Create one or more tenant configurations (array in, array out). */
+  async create(drafts, auth2 = SERVICE3) {
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(),
+      auth: auth2,
+      body: drafts
+    });
+  }
+  /** Update one tenant configuration by key. */
+  async update(key, draft, auth2 = SERVICE3) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base()}/${encodeURIComponent(key)}`,
+      auth: auth2,
+      body: draft
+    });
+  }
+  /** Delete one tenant configuration by key. */
+  async delete(key, auth2 = SERVICE3) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base()}/${encodeURIComponent(key)}`,
+      auth: auth2
+    });
+  }
+};
+
+// src/services/client-config.ts
+var SERVICE4 = { kind: "service" };
+var ClientConfigService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  ctx;
+  base(client) {
+    return `/configuration/${this.ctx.tenant}/clients/${encodeURIComponent(client)}/configurations`;
+  }
+  /** List a client's configurations, optionally filtered by `keys`. */
+  async list(client, opts = {}, auth2 = SERVICE4) {
+    const query = opts.keys && opts.keys.length > 0 ? { keys: opts.keys.join(",") } : void 0;
+    return this.ctx.http.request({
+      method: "GET",
+      path: this.base(client),
+      auth: auth2,
+      ...query ? { query } : {}
+    });
+  }
+  /** Retrieve one client configuration by key. */
+  async get(client, key, auth2 = SERVICE4) {
+    return this.ctx.http.request({
+      method: "GET",
+      path: `${this.base(client)}/${encodeURIComponent(key)}`,
+      auth: auth2
+    });
+  }
+  /** Create one or more client configurations. Injects `client` into each item. */
+  async create(client, drafts, auth2 = SERVICE4) {
+    const body = drafts.map((d) => ({ ...d, client }));
+    return this.ctx.http.request({
+      method: "POST",
+      path: this.base(client),
+      auth: auth2,
+      body
+    });
+  }
+  /** Update one client configuration by key. Injects `client` into the body. */
+  async update(client, key, draft, auth2 = SERVICE4) {
+    return this.ctx.http.request({
+      method: "PUT",
+      path: `${this.base(client)}/${encodeURIComponent(key)}`,
+      auth: auth2,
+      body: { ...draft, client }
+    });
+  }
+  /** Delete one client configuration by key. */
+  async delete(client, key, auth2 = SERVICE4) {
+    await this.ctx.http.request({
+      method: "DELETE",
+      path: `${this.base(client)}/${encodeURIComponent(key)}`,
+      auth: auth2
+    });
+  }
+};
+
+// 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
+    });
+  }
+};
+
+// package.json
+var version = "2.3.0";
+
+// src/version.ts
+var SDK_VERSION = version;
+
 // src/client.ts
-var SDK_VERSION = "0.0.0";
 var EmporixClient = class {
   customers;
   products;
@@ -2253,6 +3248,15 @@ var EmporixClient = class {
   orders;
   salesOrders;
   availability;
+  tenantConfig;
+  clientConfig;
+  shoppingLists;
+  ragIndexer;
+  sequentialIds;
+  fees;
+  webhooks;
+  schemas;
+  ai;
   /** The validated tenant this client is bound to. */
   tenant;
   /**
@@ -2323,6 +3327,15 @@ var EmporixClient = class {
     this.orders = new OrdersService(mk("orders"));
     this.salesOrders = new SalesOrdersService(mk("sales-orders"));
     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"));
   }
   /** Sets the runtime log level globally or for one service. */
   setLogLevel(level, opts = {}) {
@@ -2334,10 +3347,12 @@ var EmporixClient = class {
   }
 };
 
+exports.AiService = AiService;
 exports.AvailabilityService = AvailabilityService;
 exports.CartService = CartService;
 exports.CategoryService = CategoryService;
 exports.CheckoutService = CheckoutService;
+exports.ClientConfigService = ClientConfigService;
 exports.CompaniesService = CompaniesService;
 exports.ContactsService = ContactsService;
 exports.CustomerGroupsService = CustomerGroupsService;
@@ -2352,6 +3367,7 @@ exports.EmporixInsufficientScopeError = EmporixInsufficientScopeError;
 exports.EmporixNotFoundError = EmporixNotFoundError;
 exports.EmporixServerError = EmporixServerError;
 exports.EmporixValidationError = EmporixValidationError;
+exports.FeeService = FeeService;
 exports.HttpClient = HttpClient;
 exports.LEVEL = LEVEL;
 exports.LevelResolver = LevelResolver;
@@ -2361,10 +3377,16 @@ exports.OrdersService = OrdersService;
 exports.PaymentGatewayService = PaymentGatewayService;
 exports.PriceService = PriceService;
 exports.ProductService = ProductService;
+exports.RagIndexerService = RagIndexerService;
 exports.SalesOrdersService = SalesOrdersService;
+exports.SchemaService = SchemaService;
 exports.SegmentService = SegmentService;
+exports.SequentialIdService = SequentialIdService;
 exports.SessionContextService = SessionContextService;
+exports.ShoppingListService = ShoppingListService;
 exports.SiteService = SiteService;
+exports.TenantConfigService = TenantConfigService;
+exports.WebhookService = WebhookService;
 exports.auth = auth;
 exports.createConsoleLogger = createConsoleLogger;
 exports.createNoopLogger = createNoopLogger;