@viu/emporix-sdk 2.1.0 → 2.3.0

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { C as ClientContext, b as AuthContext, T as TokenProvider, l as ResolvedConfig, E as EmporixConfig, h as LogLevel, m as ServiceName } from './context-CGuxSb56.cjs';
-export { A as AnonymousSession, a as AnonymousSessionStore, c as AuthKind, D as DEFAULT_HOST, d as DefaultTokenProvider, H as HttpClient, e as HttpClientOptions, L as LEVEL, f as LevelResolver, g as LogFields, i as Logger, j as LoggerConfig, k as LoggerObjectConfig, P as PaginatedItems, R as RequestOptions, S as ServiceCredentials, n as StorefrontCredentials, o as auth, p as createConsoleLogger, q as createNoopLogger, r as iterateAll, s as redact, t as resolveToken, v as validateConfig } from './context-CGuxSb56.cjs';
+import { C as ClientContext, b as AuthContext, P as PaginatedItems, T as TokenProvider, l as ResolvedConfig, E as EmporixConfig, h as LogLevel, m as ServiceName } from './context-CQFcPZnt.cjs';
+export { A as AnonymousSession, a as AnonymousSessionStore, c as AuthKind, D as DEFAULT_HOST, d as DefaultTokenProvider, H as HttpClient, e as HttpClientOptions, L as LEVEL, f as LevelResolver, g as LogFields, i as Logger, j as LoggerConfig, k as LoggerObjectConfig, R as RequestOptions, S as ServiceCredentials, n as StorefrontCredentials, o as auth, p as createConsoleLogger, q as createNoopLogger, r as iterateAll, s as redact, t as resolveToken, v as validateConfig } from './context-CQFcPZnt.cjs';
 import { CustomerService } from './customer.cjs';
 export { Address, AddressCreateInput, AddressUpdateInput, Customer, CustomerSession, CustomerSignupInput, CustomerUpdateInput, PasswordChangeInput, PasswordResetConfirmInput, PasswordResetRequestInput } from './customer.cjs';
 import { ProductService } from './product.cjs';
@@ -172,6 +172,2008 @@ declare class SessionContextService {
     patch(input: SessionContextPatch, authCtx?: AuthContext): Promise<boolean>;
 }
 
+type BaseConfiguration = {
+    /**
+     * Configuration key.
+     */
+    key: string;
+    /**
+     * Configuration value. It can be any valid JSON object.
+     */
+    value: {
+        [key: string]: unknown;
+    } | string | Array<{
+        [key: string]: unknown;
+    }> | boolean;
+    /**
+     * Configuration version.
+     */
+    version?: number;
+    /**
+     * Describes purpose of the configuration.
+     */
+    description?: string;
+    /**
+     * Flag indicating whether the configuration should be encrypted. It works only if `value` field is of `string` type.
+     */
+    secured?: boolean;
+    /**
+     * Flag indicating whether the configuration should be restricted. When configuration is rectricted then it cannot be deleted. When this property is set to `true` then it cannot be unset.
+     */
+    restricted?: boolean;
+    /**
+     * Flag indicating whether the configuration should be readOnly. When configuration is readOnly then it cannot be updated.
+     */
+    readOnly?: boolean;
+    /**
+     * URL of Json Schema for validation purpose. When configuration is created this value can be provided and then each update operation will be validated against this schema. This property cannot be updated so once set it cannot be unset. The Json Schema should contain one root property named `value` in order to work correctly. An example of a valid schema: `{ "$schema": "http://json-schema.org/draft-07/schema#", "type": "object", "required": ["value"], "properties": { "value": { "type": "boolean" } } }`
+     */
+    schemaUrl?: string;
+};
+
+/**
+ * A tenant configuration entry. The wire `value` is "any JSON"; the SDK
+ * lets callers pin it with a generic (defaults to `unknown`). All other
+ * fields mirror the upstream `BaseConfiguration` schema.
+ */
+type Configuration$1<T = unknown> = Omit<BaseConfiguration, "value"> & {
+    value: T;
+};
+/** A per-client configuration entry; adds the server-assigned `_id` and `client`. */
+type ClientConfiguration<T = unknown> = Configuration$1<T> & {
+    _id: string;
+    client: string;
+};
+/** Input for create/update. Omits server-managed fields (`version`, `_id`). */
+interface ConfigurationDraft<T = unknown> {
+    key: string;
+    value: T;
+    description?: string;
+    /** Encrypts a string `value` at rest. */
+    secured?: boolean;
+    /** When true, the entry cannot be deleted. Cannot be unset once true. */
+    restricted?: boolean;
+    /** When true, the entry cannot be updated. */
+    readOnly?: boolean;
+    /** URL of a JSON Schema used to validate `value`. Immutable once set. */
+    schemaUrl?: string;
+}
+/** Options for the list endpoints. `keys` is serialized to a CSV query param. */
+interface ListConfigOptions {
+    keys?: string[];
+}
+
+/**
+ * Tenant-wide configuration (`/configuration/{tenant}/configurations`).
+ * Requires the backend-only `configuration.configuration_view` /
+ * `configuration.configuration_manage` scopes — default auth: service.
+ * Server-side use only; the service token must never reach a browser.
+ */
+declare class TenantConfigService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** List tenant configurations, optionally filtered by `keys`. */
+    list(opts?: ListConfigOptions, auth?: AuthContext): Promise<Configuration$1[]>;
+    /** Retrieve one tenant configuration by key. */
+    get<T = unknown>(key: string, auth?: AuthContext): Promise<Configuration$1<T>>;
+    /** Create one or more tenant configurations (array in, array out). */
+    create(drafts: ConfigurationDraft[], auth?: AuthContext): Promise<Configuration$1[]>;
+    /** Update one tenant configuration by key. */
+    update<T = unknown>(key: string, draft: ConfigurationDraft<T>, auth?: AuthContext): Promise<Configuration$1<T>>;
+    /** Delete one tenant configuration by key. */
+    delete(key: string, auth?: AuthContext): Promise<void>;
+}
+
+/**
+ * Per-client configuration (`/configuration/{tenant}/clients/{client}/configurations`).
+ * Requires the backend-only `configuration.configuration_view` /
+ * `configuration.configuration_manage` scopes — default auth: service.
+ * Server-side use only; the service token must never reach a browser.
+ * The `client` arg is injected into each write body so callers don't repeat it.
+ */
+declare class ClientConfigService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** List a client's configurations, optionally filtered by `keys`. */
+    list(client: string, opts?: ListConfigOptions, auth?: AuthContext): Promise<ClientConfiguration[]>;
+    /** Retrieve one client configuration by key. */
+    get<T = unknown>(client: string, key: string, auth?: AuthContext): Promise<ClientConfiguration<T>>;
+    /** Create one or more client configurations. Injects `client` into each item. */
+    create(client: string, drafts: ConfigurationDraft[], auth?: AuthContext): Promise<ClientConfiguration[]>;
+    /** Update one client configuration by key. Injects `client` into the body. */
+    update<T = unknown>(client: string, key: string, draft: ConfigurationDraft<T>, auth?: AuthContext): Promise<ClientConfiguration<T>>;
+    /** Delete one client configuration by key. */
+    delete(client: string, key: string, auth?: AuthContext): Promise<void>;
+}
+
+/** A single shopping-list line item. */
+interface ShoppingListItem {
+    id?: number;
+    productId: string;
+    quantity: number;
+    cuttingOption?: string;
+    servicePackagingOption?: string;
+    comment?: string;
+    mixins?: Record<string, unknown>;
+}
+/** A shopping list, normalized from the per-customer wire envelope. */
+interface ShoppingList {
+    key: string;
+    name: string;
+    items: ShoppingListItem[];
+    mixins?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+/** Input for create / replace. */
+interface ShoppingListDraft {
+    name: string;
+    items?: ShoppingListItem[];
+    mixins?: Record<string, unknown>;
+}
+/**
+ * Per-customer shopping lists (`/shoppinglist/{tenant}/shopping-lists`).
+ * `auth` is required: a customer token manages the caller's own lists;
+ * a service token (employee scope) can act on any `customerId`. The Emporix
+ * API has no item-level CRUD, so `addItem`/`removeItem`/`setItemQuantity`
+ * read the list and `PUT` the full body — **last-write-wins**.
+ */
+declare class ShoppingListService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** The caller's lists (or, with employee scope, all), normalized to an array. */
+    list(auth: AuthContext, opts?: {
+        name?: string;
+    }): Promise<ShoppingList[]>;
+    /** Create a list; returns the new list id. */
+    create(draft: ShoppingListDraft, auth: AuthContext): Promise<{
+        id: string;
+    }>;
+    /** Replace the named list (low-level PUT). */
+    replace(customerId: string, draft: ShoppingListDraft, auth: AuthContext): Promise<void>;
+    /** Delete the named list, or all the customer's lists when `name` is omitted. */
+    delete(customerId: string, auth: AuthContext, opts?: {
+        name?: string;
+    }): Promise<void>;
+    private loadList;
+    private put;
+    /** Add/replace an item by `productId` (read-modify-write, last-write-wins). */
+    addItem(customerId: string, listName: string, item: ShoppingListItem, auth: AuthContext): Promise<void>;
+    /** Remove an item by `productId` (no-op if absent). */
+    removeItem(customerId: string, listName: string, productId: string, auth: AuthContext): Promise<void>;
+    /** Set an item's quantity; `quantity <= 0` removes it. Adds the item if absent. */
+    setItemQuantity(customerId: string, listName: string, productId: string, quantity: number, auth: AuthContext): Promise<void>;
+}
+
+type MetadataFilter$1 = {
+    /**
+     * Unique identifier of the fields. It contains full field path.
+     */
+    key?: string;
+    /**
+     * Name of the field.
+     * @deprecated
+     */
+    name?: string;
+    /**
+     * Description of the field.
+     * @deprecated
+     */
+    description?: string;
+    /**
+     * Type of the field.
+     */
+    type?: 'string' | 'integer' | 'float' | 'boolean' | 'datetime' | 'date' | 'time' | 'dictionary' | 'list' | 'object';
+};
+
+/**
+ * A filterable metadata field exposed by the RAG index. `key` is the field
+ * name and `type` its scalar/structured kind. `name` and `description` are
+ * **deprecated** upstream — present for wire compatibility, do not rely on them.
+ */
+type MetadataFilter = MetadataFilter$1;
+/**
+ * Indexable resource type. Only `"PRODUCT"` exists today; modelled as a string
+ * union so future types can extend it without a breaking change. Every
+ * {@link RagIndexerService} method defaults its `type` argument to `"PRODUCT"`.
+ */
+type RagType = "PRODUCT";
+
+/**
+ * AI RAG Indexer (`/ai-rag-indexer/{tenant}/{type}`). Read which fields the RAG
+ * index embeds / can filter on, and trigger a full asynchronous rebuild.
+ *
+ * Requires the backend-only `ai.agent_read` (reads) / `ai.agent_manage`
+ * (`reindex`) scopes — default auth: service. **Server-side use only**; the
+ * service token must never reach a browser.
+ *
+ * Quirks: only `PRODUCT` exists today (the `type` arg defaults to it);
+ * `reindex` is a **full** rebuild (no delta), runs **asynchronously**, returns
+ * `204` once *scheduled* (not on completion), has **no status endpoint** to
+ * poll, and is costly — call it sparingly. The set of embedded fields is
+ * configured in the AI Service, not here.
+ */
+declare class RagIndexerService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** The indexable embedding field names for `type` (default `"PRODUCT"`). */
+    ragMetadata(type?: RagType, auth?: AuthContext): Promise<string[]>;
+    /** The filterable metadata fields for `type` (default `"PRODUCT"`). */
+    filterMetadata(type?: RagType, auth?: AuthContext): Promise<MetadataFilter[]>;
+    /**
+     * 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.
+     */
+    reindex(type?: RagType, auth?: AuthContext): Promise<void>;
+}
+
+type SequenceSchema$1 = SequenceSchemaCreate$1 & {
+    /**
+     * Flag indicating whether the schema is active.
+     */
+    active?: boolean;
+    /**
+     * ID of the sequence schema.
+     */
+    id?: string;
+    /**
+     * Number of created IDs based on the selected schema.
+     */
+    counter?: number;
+    metadata?: {
+        /**
+         * Date of creation.
+         */
+        createdAt?: string;
+        /**
+         * Date of last modification.
+         */
+        modifiedAt?: string;
+        /**
+         * The version number.
+         */
+        version?: number;
+    };
+};
+/**
+ * The filler text for values based on certain properties or settings in the system.
+ */
+type Placeholders = {
+    [key: string]: {
+        required?: boolean;
+        default?: string;
+    };
+};
+type SequenceSchemaCreate$1 = {
+    /**
+     * The name of the sequence schema.
+     */
+    name: string;
+    /**
+     * The schema type corresponding to the entity it is used for. Possible values are:
+     * - `orderNoSequence`
+     * - `invoiceNoSequence`
+     * - `quoteNoSequence`
+     * - `pickPackNoSequence`
+     * - `orderHoldingAreaNoSequence`
+     *
+     */
+    schemaType?: string;
+    /**
+     * The prefix of the ID. It can contain placeholders, which are replaced with their values.
+     * Placeholders are defined in the `placeholders` property.
+     *
+     */
+    preText?: string;
+    /**
+     * The suffix of the ID. It can contain placeholders, which are replaced with their values.
+     * Placeholders are defined in the `placeholders` property.
+     *
+     */
+    postText?: string;
+    /**
+     * The starting value of the sequence. It is used to generate the first ID.
+     * The starting value is incremented for each subsequent ID.
+     *
+     */
+    startValue: number;
+    /**
+     * The maximum value of the sequence. It is used to limit the range of generated IDs.
+     * If the maximum value is reached, the sequence will not generate any more IDs.
+     *
+     */
+    maxValue: number;
+    /**
+     * The number of digits in the generated ID. It is used to format the ID.
+     * If the number of digits is less than the maximum value, leading zeros are added.
+     *
+     */
+    numberOfDigits: number;
+    placeholders?: Placeholders;
+};
+type NextIdCommandRequest$1 = {
+    /**
+     * The pattern to follow for the nextID.
+     */
+    sequenceKey?: string;
+    /**
+     * The filler text for values based on certain properties or settings in the system.
+     */
+    placeholders?: unknown;
+};
+
+/**
+ * A sequence schema as returned by the service — a counter template plus the
+ * server-managed `id`, `active` flag, `counter`, and `metadata`.
+ */
+type SequenceSchema = SequenceSchema$1;
+/**
+ * Body for {@link SequentialIdService.createSchema}. Schemas are immutable
+ * (no PATCH/PUT upstream) — to change one, delete it and create a new one.
+ */
+type SequenceSchemaCreate = SequenceSchemaCreate$1;
+/**
+ * Body for a single next-id request: optional sub-pool key + placeholder values.
+ * The generated spec widens `placeholders` to `unknown`; the SDK types it as the
+ * documented `key → value` string map.
+ */
+type NextIdCommandRequest = Omit<NextIdCommandRequest$1, "placeholders"> & {
+    placeholders?: Record<string, string>;
+};
+/** The generated id returned by `nextId` (always present on a successful call). */
+interface NextIdResponse {
+    id: string;
+}
+/** Per-call options for {@link SequentialIdService.nextId}. */
+interface NextIdOptions {
+    /**
+     * A site code. When set, the service derives time/country placeholders from
+     * that site's settings. Serialized to the `?siteCode=` query param.
+     */
+    siteCode?: string;
+}
+/** One entry in a batch next-ids request, keyed by schema type. */
+interface BatchNextIdEntry {
+    /** How many ids to allocate for this schema type. */
+    numberOfIds: number;
+    /** Optional independent sub-pool counter key. */
+    sequenceKey?: string;
+    /** Placeholder values substituted into the generated ids. */
+    placeholders?: Record<string, string>;
+}
+/** Batch next-ids request: a map of `schemaType` → allocation request. */
+type NextIdsBatchRequest = Record<string, BatchNextIdEntry>;
+/** Batch next-ids response: a map of `schemaType` → the generated ids. */
+type NextIdsBatchResponse = Record<string, {
+    ids: string[];
+}>;
+
+/**
+ * Sequential ID Service (`/sequential-id/{tenant}/…`): server-managed,
+ * gap-free sequential identifiers (order/invoice numbers, etc.) driven by
+ * tenant-defined sequence schemas.
+ *
+ * Requires the backend-only `sequentialid.schema_view` (read + next-id) /
+ * `sequentialid.schema_manage` (CRUD + set-active) scopes — default auth:
+ * service. Server-side use only; the service token must never reach a browser.
+ *
+ * Schemas are immutable upstream (no PATCH/PUT): to change one, `deleteSchema`
+ * then `createSchema`. The `maxValue` is a hard cap with no auto-reset, and
+ * only one schema may be active per type.
+ */
+declare class SequentialIdService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** List all sequence schemas for the tenant. */
+    listSchemas(auth?: AuthContext): Promise<SequenceSchema[]>;
+    /** Retrieve one sequence schema by id. */
+    getSchema(schemaId: string, auth?: AuthContext): Promise<SequenceSchema>;
+    /** Create a sequence schema. Schemas are immutable — there is no update. */
+    createSchema(schema: SequenceSchemaCreate, auth?: AuthContext): Promise<SequenceSchema>;
+    /** Delete a sequence schema by id. */
+    deleteSchema(schemaId: string, auth?: AuthContext): Promise<void>;
+    /** Mark a schema active for its type (only one schema may be active per type). */
+    setActiveSchema(schemaId: string, auth?: AuthContext): Promise<void>;
+    /** Get the active schema for a given schema type. */
+    listSchemasByType(schemaType: string, auth?: AuthContext): Promise<SequenceSchema>;
+    /**
+     * 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.
+     */
+    nextId(schemaType: string, body?: NextIdCommandRequest, opts?: NextIdOptions, auth?: AuthContext): Promise<NextIdResponse>;
+    /**
+     * 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.
+     */
+    nextIdsBatch(req: NextIdsBatchRequest, auth?: AuthContext): Promise<NextIdsBatchResponse>;
+}
+
+/**
+ * The localized value in the form of map (language, value) or string.
+ */
+type Localized$1 = string | {
+    [key: string]: string;
+};
+type Fee$1 = {
+    /**
+     * Unique identifier of the fee.
+     */
+    id?: string;
+    name: Localized$1;
+    description?: Localized$1;
+    /**
+     * The code-name, unique for the tenant.
+     */
+    code: string;
+    /**
+     * 'PERCENT' for relative values, 'ABSOLUTE' for float values or 'ABSOLUTE_MULTIPLY_ITEMQUANTITY' for float values to be multiplied by the quantity of the item.
+     */
+    feeType: 'PERCENT' | 'ABSOLUTE' | 'ABSOLUTE_MULTIPLY_ITEMQUANTITY';
+    /**
+     * The fee rate in percentage. Required if feeType is 'PERCENT'.
+     */
+    feePercentage?: number;
+    feeAbsolute?: MonetaryAmount;
+    /**
+     * The itemtype the fee can belong to. It could be a product or
+     * paymenttype.
+     */
+    itemType?: 'PRODUCT' | 'PAYMENTTYPE';
+    /**
+     * The SiteCode the fee belongs to.
+     */
+    siteCode: string;
+    /**
+     * Flag indicating whether the fee is currently active or not.
+     */
+    active: boolean;
+    /**
+     * Flag indicating whether the fee is taxable or not.
+     */
+    taxable?: boolean;
+    /**
+     * The tax code. When 'taxable' is set to true, the taxCode is mandatory
+     */
+    taxCode?: string;
+    activeTimespan?: Timespan;
+    yrn?: Yrn;
+};
+/**
+ * Schema defining monetary amount in given currency.
+ */
+type MonetaryAmount = {
+    /**
+     * The amount in the specified currency
+     */
+    amount: number;
+    /**
+     * ISO 4217 currency code, e.g.: USD, EUR, CHF
+     */
+    currency: string;
+};
+/**
+ * Restricts the active fees to be only applied in the specified
+ * timespan.
+ */
+type Timespan = {
+    startDate: string;
+    endDate: string;
+};
+type ItemFee$1 = {
+    /**
+     * Unique identifier of the item fee.
+     */
+    id?: string;
+    /**
+     * The SiteCode this fee belongs to.
+     */
+    siteCode: string;
+    /**
+     * YRN of the item to assign fees to.
+     */
+    itemYrn: string;
+    /**
+     * List of unique identifiers of fees to assign to the item.
+     */
+    feeIds: Array<string>;
+};
+/**
+ * A unique identifier of a global resource, which stores information about the resource, such as its type, ID or name of the tenant.
+ */
+type Yrn = string;
+
+/** A fee definition as returned by the API (`id`/`yrn` server-assigned). */
+type Fee = Fee$1;
+/** An item-fee (or product-fee) mapping as returned by the API. */
+type ItemFee = ItemFee$1;
+/**
+ * Body for create/update of a fee definition — {@link Fee} minus the
+ * server-assigned `id`/`yrn`. (The upstream spec reuses the `Fee` schema as the
+ * request body; the SDK exposes this narrower draft type.)
+ */
+type FeeDraft = Omit<Fee, "id" | "yrn">;
+/** Body for `POST /itemFees` — {@link ItemFee} minus the server `id`. */
+type ItemFeeDraft = Omit<ItemFee, "id">;
+/** Body of `POST /itemFees/search`. */
+interface ItemFeeSearch {
+    itemYrns: string[];
+    siteCode: string;
+}
+/**
+ * Query for the paginated `GET /fees` list. Explicit fields are typed for
+ * autocomplete; the index signature stays open so Emporix `q`-syntax filters
+ * pass through verbatim (mirrors `ListAssetsQuery` in `media`).
+ */
+interface ListFeesQuery {
+    pageNumber?: number;
+    pageSize?: number;
+    /** Emporix sort syntax, e.g. `"code:asc"`. */
+    sort?: string;
+    /** Emporix `q`-syntax filter, e.g. `"siteCode:main"`. */
+    q?: string;
+    [key: string]: string | number | undefined;
+}
+/** Options for {@link FeeService.setItemFees} / {@link FeeService.setProductFees}. */
+interface SetItemFeesOptions {
+    /** When true, merges instead of replacing (serialized to `?partial=true`). */
+    partial?: boolean;
+}
+
+/**
+ * Emporix Fee Service (`/fee/{tenant}/…`): fee definitions plus the
+ * item/product mappings that attach them. Writes require a backend-only scope
+ * (`fee.fee_*` / `fee.item_*`); GETs need a token but no scope. Default auth:
+ * service. Server-side use only — the service token must never reach a browser.
+ *
+ * Quirks (server behavior, not handled here): a payment-type fee's `code` must
+ * equal the payment-mode code or the fee is silently ignored; a wrong/missing
+ * `siteCode` filters to an empty array rather than erroring; an expired
+ * `activeTimespan` silently disables the fee; `setItemFees`/`setProductFees`
+ * replace the whole mapping unless `partial` is set.
+ */
+declare class FeeService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private feesBase;
+    private itemFeesBase;
+    private productFeesBase;
+    /**
+     * 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`).
+     */
+    list(query?: ListFeesQuery, auth?: AuthContext): Promise<PaginatedItems<Fee>>;
+    /** Retrieve one fee definition by id. */
+    get(id: string, auth?: AuthContext): Promise<Fee>;
+    /** Create a fee definition. */
+    create(draft: FeeDraft, auth?: AuthContext): Promise<Fee>;
+    /** Update a fee definition by id. */
+    update(id: string, draft: FeeDraft, auth?: AuthContext): Promise<Fee>;
+    /** Delete a fee definition by id. */
+    delete(id: string, auth?: AuthContext): Promise<void>;
+    /** List all item-fee mappings. */
+    listItemFees(auth?: AuthContext): Promise<ItemFee[]>;
+    /** Fee mappings for one item YRN. */
+    getItemFees(itemYrn: string, auth?: AuthContext): Promise<ItemFee[]>;
+    /** Create an item-fee mapping. */
+    createItemFee(draft: ItemFeeDraft, auth?: AuthContext): Promise<ItemFee>;
+    /**
+     * Set the fee list for an item YRN. Destructive replace by default; pass
+     * `{ partial: true }` to merge (`?partial=true`).
+     */
+    setItemFees(itemYrn: string, feeIds: string[], opts?: SetItemFeesOptions, auth?: AuthContext): Promise<ItemFee>;
+    /**
+     * Delete item-fee mappings for a YRN. Without `feeId`, removes all mappings
+     * for the YRN; with `feeId`, removes that single fee from the mapping.
+     */
+    deleteItemFees(itemYrn: string, feeId?: string, auth?: AuthContext): Promise<void>;
+    /** Search item-fee mappings by item YRNs + site. */
+    searchItemFees(search: ItemFeeSearch, auth?: AuthContext): Promise<ItemFee[]>;
+    /** Fee mappings for a product id. */
+    getProductFees(productId: string, auth?: AuthContext): Promise<ItemFee[]>;
+    /**
+     * Set the fee list for a product id. Destructive replace by default; pass
+     * `{ partial: true }` to merge (`?partial=true`).
+     */
+    setProductFees(productId: string, feeIds: string[], opts?: SetItemFeesOptions, auth?: AuthContext): Promise<ItemFee>;
+    /** Delete all fee mappings for a product id. */
+    deleteProductFees(productId: string, auth?: AuthContext): Promise<void>;
+}
+
+type AbstractWebhookConfig = {
+    /**
+     * Indicates whether a given configuration is active. Only one configuration can be active.
+     */
+    active?: boolean;
+    provider?: Provider;
+};
+/**
+ * SVIX_SHARED config
+ */
+type EmptyConfiguration = {
+    [key: string]: unknown;
+};
+/**
+ * SVIX config
+ */
+type SvixConfig = {
+    /**
+     * API Key for connecting to SVIX. This API Key will be then used in `Authorization` header while sending requests to SVIX, so the value should include `Bearer` prefix if necessary.
+     */
+    apiKey?: string;
+};
+type EventConfiguration = {
+    /**
+     * Unique identifier of the event.
+     */
+    eventType?: string;
+    /**
+     * Optional secret key which could be used to sign the message. This secret is used in `HMAC SHA 256` algorithm which encrypts the payload. Then this value is encoded to `BASE256` and included in `emporix-event-signature` header of HTTP request. It has higher priority than `secretKey` on root level. Each event can have defined a separated secret key.
+     */
+    secretKey?: string;
+    /**
+     * Destination URL where event should be sent. It has higher priority than `destinationUrl` on root level. Each event can have defined a separated destination url.
+     */
+    destinationUrl?: string;
+    /**
+     * List of key-value pairs which can decorate outgoing HTTP POST request as headers. The size limit for this list is `10`. It has higher priority than `headers` on root level. Each event can have defined a separated headers.
+     */
+    headers?: HttpHeadersConfig;
+};
+type EventsConfiguration = Array<EventConfiguration>;
+type HttpHeaderConfigValue = {
+    value?: string;
+};
+type HttpHeadersConfig = {
+    [key: string]: HttpHeaderConfigValue;
+};
+/**
+ * HTTP config
+ */
+type HttpConfig = {
+    /**
+     * Optional secret key which could be used to sign the message. This secret is used in `HMAC SHA 256` algorithm which encrypts the payload. Then this value is encoded to `BASE256` and included in `emporix-event-signature` header of HTTP request.
+     */
+    secretKey?: string;
+    /**
+     * Destination URL where event should be sent.
+     */
+    destinationUrl?: string;
+    /**
+     * List of key-value pairs which can decorate outgoing HTTP POST request as headers. The size limit for this list is `10`.
+     */
+    headers?: HttpHeadersConfig;
+    eventsConfiguration?: EventConfiguration;
+};
+type Configuration = EmptyConfiguration | SvixConfig | HttpConfig;
+type WebhookConfigPartialUpdate = {
+    /**
+     * Kind of the update operation
+     */
+    op: 'REMOVE' | 'UPSERT';
+    /**
+     * Path for identyifing which properties should be updated
+     */
+    path: '/active' | '/configuration' | '/configuration/svix/apiKey' | '/configuration/http/headers' | '/configuration/http/destinationUrl' | '/configuration/http/secretKey' | '/configuration/http/eventsConfiguration' | '/configuration/http/eventsConfiguration/{eventType}' | '/configuration/http/eventsConfiguration/{eventType}/destinationUrl' | '/configuration/http/eventsConfiguration/{eventType}/secretKey' | '/configuration/http/eventsConfiguration/{eventType}/headers';
+    value?: SvixConfig | HttpConfig | string | boolean | EventsConfiguration | EventConfiguration;
+};
+type ConfigurationGet = {
+    /**
+     * Destination URL where event should be sent.
+     */
+    destinationUrl?: string;
+    /**
+     * Information if secret key for securing the messages has been provided.
+     */
+    secretKeyExists?: boolean;
+    /**
+     * List of key-value pairs which can decorate outgoing HTTP POST request as headers.
+     */
+    headers?: HttpHeadersConfig;
+    eventsConfiguration?: Array<{
+        /**
+         * Type of the event.
+         */
+        eventType?: string;
+        /**
+         * Destination URL where event should be sent.
+         */
+        destinationUrl?: string;
+        /**
+         * Information if secret key for securing the messages has been provided.
+         */
+        secretKeyExists?: boolean;
+        /**
+         * List of key-value pairs which can decorate outgoing HTTP POST request as headers.
+         */
+        headers?: HttpHeadersConfig;
+    }>;
+};
+/**
+ * Unique identifier of webhook configuration.
+ */
+type ConfigCode = string;
+type Provider = 'SVIX_SHARED' | 'SVIX' | 'HTTP';
+type WebhookConfigUpdate = AbstractWebhookConfig & {
+    configuration?: Configuration;
+};
+type WebhookConfigCreation = WebhookConfigUpdate & {
+    code: ConfigCode;
+};
+/**
+ * Events that you can subscribe to.
+ */
+type WebhookEvent = {
+    /**
+     * Unique identifier of the event.
+     */
+    type?: string;
+    /**
+     * Map of key-value pairs containing localized descriptions of the event, which includes information on when the event is emitted.
+     */
+    description?: {
+        [key: string]: string;
+    };
+    /**
+     * Schema of the event.
+     */
+    eventSchema?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Map of key-value pairs containing localized names of the event.
+     */
+    name?: {
+        [key: string]: string;
+    };
+    /**
+     * Map of key-value pairs containing the localized name of a group the event belongs to.
+     */
+    group?: {
+        [key: string]: string;
+    };
+};
+/**
+ * Subscription per event.
+ */
+type WebhookSubscription$1 = {
+    event?: WebhookEvent;
+    metadata?: Metadata;
+    /**
+     * Status of the subscription.
+     */
+    subscription?: 'SUBSCRIBED' | 'UNSUBSCRIBED' | 'NONE';
+    /**
+     * If `subscription` is of type `SUBSCRIBED`, `excludedFields` will contain the list of keys from the "event.eventSchema" that the user has previously unsubscribed from. Note: Only root level fields are supported.
+     */
+    excludedFields?: Array<string>;
+};
+/**
+ * Object used to subscribe to/unsubscribe from an event.
+ */
+type WebhookSubscriptionUpdateItem$1 = {
+    /**
+     * Unique identifier of the event.
+     */
+    eventType: string;
+    /**
+     * Indicates whether the event should be subscribed to or unsubscribed from.
+     */
+    action?: 'SUBSCRIBE' | 'UNSUBSCRIBE';
+    metadata?: MetadataForUpdate;
+    /**
+     * Fields to exclude from notification.
+     */
+    fieldsToUnsubscribe?: Array<string>;
+    /**
+     * Fields to re-include in the notification. To be used when user wants to subscribe to previously unsubscribed fields.
+     */
+    fieldsToSubscribe?: Array<string>;
+};
+/**
+ * Auditing details.
+ */
+type Metadata = {
+    /**
+     * Date and time when the document was created.
+     */
+    createdAt?: string;
+    /**
+     * Date and time when the document was last modified.
+     */
+    modifiedAt?: string;
+    /**
+     * Version of the document.
+     */
+    version?: number;
+};
+/**
+ * Auditing details.
+ */
+type MetadataForUpdate = {
+    /**
+     * Version of the document.
+     */
+    version?: number;
+};
+/**
+ * Object containing the result of event subscription.
+ */
+type UpdateSubscriptionResponse = {
+    eventType?: string;
+    code?: number;
+    status?: string;
+    message?: string;
+};
+type DashboardAccess = {
+    /**
+     * Svix application dashboard access URL with embedded authentication.
+     */
+    url?: string;
+    /**
+     * Authentication token for accessing the Svix application dashboard.
+     */
+    token?: string;
+};
+type MonthStatistics = {
+    /**
+     * Month for which statistics should be retrieved, provided in the "YYYY-MM" format.
+     */
+    statisticsMonth?: string;
+    /**
+     * Number of events sent successfully to the customer's configured endpoints.
+     */
+    succesfullySentWebhooks?: number;
+};
+type WebhookStatistics$1 = {
+    monthStatistics?: Array<MonthStatistics>;
+    /**
+     * Maximum number of events that the tenant is allowed to send in a specified month.
+     */
+    webhooksLimit?: number;
+};
+
+/** A webhook event subscription (read model): the event metadata + on/off state. */
+type WebhookSubscription = WebhookSubscription$1;
+/** One item of the batch `PATCH /event-subscriptions` body. `eventType` is required. */
+type WebhookSubscriptionUpdateItem = WebhookSubscriptionUpdateItem$1;
+/**
+ * One element of the **207** result returned by `updateEventSubscriptions`.
+ * `code`/`status` reflect per-item success/failure — the batch can partially fail.
+ */
+type WebhookSubscriptionUpdateResultItem = UpdateSubscriptionResponse;
+/**
+ * A webhook delivery configuration as returned by `getConfig`/`listConfigs`:
+ * `active`/`provider` plus the server-assigned `code` and read-only
+ * `configuration` (the `secretKey` is never returned — only `secretKeyExists`).
+ */
+type WebhookConfig = AbstractWebhookConfig & {
+    code?: ConfigCode;
+    configuration?: ConfigurationGet;
+};
+/** Body for `createConfig` / `replaceConfig` (carries `code`; `secretKey` is write-only). */
+type WebhookConfigDraft = WebhookConfigCreation;
+/**
+ * One operation of the `patchConfig` body. The PATCH endpoint takes an **array**
+ * of these `{ op, path, value }` operations (UPSERT / REMOVE).
+ */
+type WebhookConfigPatch = WebhookConfigPartialUpdate;
+/** Response of `createConfig`. */
+interface WebhookConfigCreated {
+    code: string;
+}
+/** Webhook delivery statistics (SVIX_SHARED-oriented). */
+type WebhookStatistics = WebhookStatistics$1;
+/** Svix dashboard access (URL / token) returned by `getDashboardAccess`. */
+type WebhookDashboardAccess = DashboardAccess;
+/** Query for `getStatistics`. Both bounds are `YYYY-MM`; omitted when absent. */
+interface WebhookStatisticsQuery {
+    fromYearMonth?: string;
+    toYearMonth?: string;
+}
+/** Options for `deleteConfig`. */
+interface DeleteConfigOptions {
+    /** Required to delete the currently-active config. Serialized as `?force=true`. */
+    force?: boolean;
+}
+
+/**
+ * Webhook administration (`/webhook/{tenant}/…`): the event-subscription
+ * catalog and batch toggle, delivery-config CRUD, statistics, and Svix
+ * dashboard access. Requires the backend-only `webhook.subscription_read` /
+ * `webhook.subscription_manage` scopes — default auth: service. Server-side
+ * use only; the service token must never reach a browser.
+ */
+declare class WebhookService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** List the event-subscription catalog with each event's on/off state. */
+    listEventSubscriptions(auth?: AuthContext): Promise<WebhookSubscription[]>;
+    /**
+     * 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.
+     */
+    updateEventSubscriptions(items: WebhookSubscriptionUpdateItem[], auth?: AuthContext): Promise<WebhookSubscriptionUpdateResultItem[]>;
+    /** List delivery configurations. */
+    listConfigs(auth?: AuthContext): Promise<WebhookConfig[]>;
+    /** Retrieve one delivery configuration by code. */
+    getConfig(code: string, auth?: AuthContext): Promise<WebhookConfig>;
+    /** Create a delivery configuration. Returns the server-assigned `{ code }`. */
+    createConfig(draft: WebhookConfigDraft, auth?: AuthContext): Promise<WebhookConfigCreated>;
+    /** Replace a delivery configuration by code (204). */
+    replaceConfig(code: string, draft: WebhookConfigDraft, auth?: AuthContext): Promise<void>;
+    /**
+     * Partially update a delivery configuration by code (204). The body is an
+     * **array** of `{ op, path, value }` operations (UPSERT / REMOVE).
+     */
+    patchConfig(code: string, patches: WebhookConfigPatch[], auth?: AuthContext): Promise<void>;
+    /**
+     * Delete a delivery configuration by code. Pass `{ force: true }` to delete
+     * the currently-active config (the server otherwise rejects it).
+     */
+    deleteConfig(code: string, opts?: DeleteConfigOptions, auth?: AuthContext): Promise<void>;
+    /** Read delivery statistics over an optional `YYYY-MM` range. */
+    getStatistics(query?: WebhookStatisticsQuery, auth?: AuthContext): Promise<WebhookStatistics>;
+    /** Obtain Svix dashboard access (URL / token). */
+    getDashboardAccess(auth?: AuthContext): Promise<WebhookDashboardAccess>;
+}
+
+/**
+ * Type which the schema should be assigned to. Can be one of the predefined values or any custom schema type id.
+ */
+type SchemaType = 'CART' | 'CART_ITEM' | 'CATEGORY' | 'COMPANY' | 'COUPON' | 'CUSTOMER' | 'CUSTOMER_ADDRESS' | 'ORDER' | 'ORDER_ENTRY' | 'PRODUCT' | 'QUOTE' | 'RETURN' | 'PRICE_LIST' | 'SITE' | 'CUSTOM_ENTITY' | 'VENDOR';
+/**
+ * Type of the attribute.
+ *
+ * **Note**: The `REFERENCE` type is only available for custom schema types.
+ *
+ */
+type SchemaAttributeType = 'TEXT' | 'NUMBER' | 'DECIMAL' | 'BOOLEAN' | 'DATE' | 'TIME' | 'DATE_TIME' | 'ENUM' | 'ARRAY' | 'OBJECT' | 'REFERENCE';
+/**
+ * Whether the attribute is localized or not. Only attributes of 'TEXT' type can be localized.
+ */
+type Localized = boolean;
+/**
+ * Metadata of the schema attribute.
+ */
+type SchemaAttributeMetadata = {
+    /**
+     * Whether the attribute is read-only or not.
+     */
+    readOnly?: boolean;
+    localized?: Localized;
+    /**
+     * Whether the attribute is required or not. Attributes of 'BOOLEAN' type cannot be required.
+     */
+    required?: boolean;
+    /**
+     * Whether the attribute could accept null or not.
+     */
+    nullable?: boolean;
+};
+/**
+ * Value of the attribute. Valid for `ENUM` and `REFERENCE` types.
+ *
+ * For `ENUM` type, the value represents one of the allowed enum values.
+ *
+ * For `REFERENCE` type, the value represents the reference type (e.g., `PRODUCT`, `ORDER`, `ORDER_ENTRY`, `CART`, `CART_ITEM`, `PRICE`, `CUSTOMER`, `COMPANY`, `MEDIA`, `PRICE_LIST`, `CUSTOMER_SEGMENT`, `CATEGORY`, or any custom schema type).
+ *
+ */
+type SchemaAttributeValue = {
+    value: string;
+};
+/**
+ * Schema attribute.
+ */
+type SchemaAttribute$1 = {
+    /**
+     * Unique key of the attribute.
+     */
+    key: string;
+    /**
+     * Localized schema name in a form of a map of translations.
+     */
+    name: {
+        [key: string]: unknown;
+    };
+    /**
+     * Localized schema description in a form of a map of translations.
+     */
+    description?: {
+        [key: string]: unknown;
+    };
+    type: SchemaAttributeType;
+    metadata: SchemaAttributeMetadata;
+    /**
+     * List of available values for the attribute. Only valid for `ENUM` and `REFERENCE` type.
+     */
+    values?: Array<SchemaAttributeValue>;
+    /**
+     * Object's properties. It can only be provided for attribute of `OBJECT` type.
+     */
+    attributes?: Array<SchemaAttribute$1>;
+    /**
+     * Contains information about the type used inside an array. It can only be provided for attribute of `ARRAY` type.
+     */
+    arrayType?: {
+        type: SchemaAttributeType;
+        /**
+         * List of available values for the attribute. Only valid for `ENUM` and `REFERENCE` type.
+         */
+        values?: Array<SchemaAttributeValue>;
+        localized?: Localized;
+    };
+};
+type SchemaMetadataUpdate = {
+    /**
+     * Version of the object. The value is required during update operation.
+     */
+    version?: number;
+};
+type SchemaMetadata = SchemaMetadataUpdate & {
+    /**
+     * Schema url of the attributes.
+     */
+    url?: string;
+    /**
+     * Date and time when the object was created, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+     */
+    createdAt?: string;
+    /**
+     * Date and time when the object was last modified, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+     */
+    modifiedAt?: string;
+};
+type AbstractSchemaResponse = {
+    /**
+     * Identifier of the schema.
+     */
+    id?: string;
+    /**
+     * Localized schema name in a form of a map of translations.
+     */
+    name?: {
+        [key: string]: unknown;
+    };
+    /**
+     * List of types to which schema should be assigned.
+     */
+    types?: Array<SchemaType>;
+    metadata?: SchemaMetadata;
+};
+type SchemaResponse = AbstractSchemaResponse & {
+    /**
+     * List of attributes related to the schema.
+     */
+    attributes?: Array<SchemaAttribute$1>;
+};
+type CustomSchemaTypeResponse = {
+    /**
+     * Unique id of the custom schema type.
+     */
+    id?: string;
+    /**
+     * Localized custom type name in a form of a map of translations.
+     */
+    name?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Information about associated schemas. This field is only included if `expandSchemas` is set to `true`
+     */
+    schemas?: {
+        [key: string]: unknown;
+    };
+    metadata?: {
+        /**
+         * Date and time when the object was created, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+         */
+        createdAt?: string;
+        /**
+         * Date and time when the object was last modified, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+         */
+        modifiedAt?: string;
+        version?: number;
+    };
+};
+/**
+ * Ownership of the custom instance. It can be assigned explicitly during creation by users with a `manage` scope, or populated automatically based on who created the custom instance. Once set, the owner is immutable and cannot be modified.
+ *
+ * The `legalEntityId` field is only present when `type` is `CUSTOMER`.
+ *
+ */
+type CustomInstanceOwner = {
+    /**
+     * Type of the owner.
+     */
+    type: 'EMPLOYEE' | 'CUSTOMER' | 'SERVICE';
+    /**
+     * Identifier of the employee, customer, or service principal associated with the owner.
+     */
+    userId: string;
+    /**
+     * Legal entity identifier. Only set when `type` is `CUSTOMER`.
+     */
+    legalEntityId?: string | null;
+};
+type CustomInstanceResponse = {
+    /**
+     * Unique identifier of the custom instance.
+     */
+    id?: string;
+    /**
+     * Localized custom type name in a form of a map of translations.
+     */
+    name?: {
+        [key: string]: unknown;
+    };
+    /**
+     * Custom schema type to which custom instance is related.
+     */
+    type?: string;
+    owner?: CustomInstanceOwner;
+    /**
+     * A key-value map of additional attributes.
+     */
+    mixins?: string;
+    /**
+     * List of media IDs assigned to the custom instance.
+     */
+    media?: Array<string>;
+    metadata?: CustomInstanceMetadata;
+};
+type CustomInstanceMetadata = {
+    /**
+     * Date and time when the object was created, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+     */
+    createdAt?: string;
+    /**
+     * Date and time when the object was last modified, compliant with the ISO 8601 standard. For example: `2022-03-31T09:52:15.423Z`
+     */
+    modifiedAt?: string;
+    /**
+     * Version of the custom instance.
+     */
+    version?: number;
+    /**
+     * A key-value map, where key is a mixin name and value is a link to the mixin schema.
+     */
+    mixins?: {
+        [key: string]: unknown;
+    };
+};
+
+/** A schema definition (typed attributes attached to one or more entity types). */
+type Schema = SchemaResponse;
+/** A single typed attribute within a schema (recursive for `OBJECT`). */
+type SchemaAttribute = SchemaAttribute$1;
+/**
+ * The set of native entity types a schema can attach to
+ * (`PRODUCT`, `CART`, `ORDER`, `CUSTOM_ENTITY`, …).
+ */
+type SchemaTypeName = SchemaType;
+/** A custom-entity definition (a tenant-defined resource type). */
+type CustomEntity = CustomSchemaTypeResponse;
+/**
+ * A custom-entity data record. The wire `mixins` field is loosely typed
+ * upstream; the SDK lets callers pin it with a generic (defaults to an open
+ * record). All other fields mirror the upstream `CustomInstanceResponse`.
+ */
+type CustomInstance<T = Record<string, unknown>> = Omit<CustomInstanceResponse, "mixins"> & {
+    mixins: T;
+};
+/**
+ * Input for creating a schema (server assigns `metadata.version`/`url`).
+ * `name`, `types` and `attributes` are the caller-controlled fields.
+ */
+interface SchemaDraft {
+    name: Record<string, string>;
+    types: SchemaTypeName[];
+    attributes: SchemaAttribute[];
+}
+/**
+ * Input for updating a schema. Identical to {@link SchemaDraft} but the
+ * upstream API **requires** `metadata.version` for optimistic locking
+ * (409 Conflict on a stale version).
+ */
+interface SchemaUpdate extends SchemaDraft {
+    metadata: {
+        version: number;
+    };
+}
+/** Input for creating/updating a custom-entity definition. */
+interface CustomEntityDraft {
+    name: Record<string, string>;
+    attributes: SchemaAttribute[];
+}
+/** Input for creating/replacing a custom instance. `mixins` carries the data. */
+interface CustomInstanceDraft<T = Record<string, unknown>> {
+    name: Record<string, string>;
+    mixins: T;
+}
+/** Filter / pagination options for {@link SchemaService.listSchemas}. */
+interface ListSchemasQuery {
+    /** Emporix `q`-syntax filter (supports `compoundLogicalQuery`). */
+    q?: string;
+    /** Restrict to schemas attached to this entity type. */
+    type?: SchemaTypeName;
+    pageNumber?: number;
+    pageSize?: number;
+}
+/**
+ * Pagination options for {@link SchemaService.listInstances}. The index
+ * signature stays open so additional Emporix query params pass through.
+ */
+interface ListInstancesQuery {
+    pageNumber?: number;
+    pageSize?: number;
+    [key: string]: string | number | undefined;
+}
+/** Options for {@link SchemaService.listCustomEntities}. */
+interface ListCustomEntitiesOptions {
+    /** Inline each entity's schema body in the response. */
+    expandSchemas?: boolean;
+}
+/** Structured search filter body for {@link SchemaService.searchInstances}. */
+type InstanceSearchBody = Record<string, unknown>;
+
+/**
+ * Schema Service (`/schema/{tenant}/…`): schemas, entity types, custom
+ * entities and their instances. Requires the backend-only `schema.schema_*`
+ * / `schema.custominstance_*` scopes — default auth: service. Server-side use
+ * only; the service token must never reach a browser.
+ */
+declare class SchemaService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private schemasBase;
+    private entitiesBase;
+    private instancesBase;
+    /**
+     * 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`).
+     */
+    listSchemas(query?: ListSchemasQuery, auth?: AuthContext): Promise<PaginatedItems<Schema>>;
+    /** Retrieve one schema by id. */
+    getSchema(id: string, auth?: AuthContext): Promise<Schema>;
+    /** Create a schema. */
+    createSchema(draft: SchemaDraft, auth?: AuthContext): Promise<Schema>;
+    /**
+     * Update a schema. The upstream API requires `draft.metadata.version`; a
+     * stale version yields 409 Conflict (propagated as the standard conflict
+     * error).
+     */
+    updateSchema(id: string, draft: SchemaUpdate, auth?: AuthContext): Promise<Schema>;
+    /** Delete a schema by id. */
+    deleteSchema(id: string, auth?: AuthContext): Promise<void>;
+    /**
+     * Validate a schema document without persisting it (`POST /schemas/file`).
+     * Returns the server's validation result verbatim.
+     */
+    validateSchemaFile<R = unknown>(body: SchemaDraft, auth?: AuthContext): Promise<R>;
+    /** List entity types that currently have at least one schema. */
+    listTypes(auth?: AuthContext): Promise<SchemaTypeName[]>;
+    /** Set the entity types a schema applies to (`PUT /schemas/{id}/types`). */
+    setSchemaTypes(id: string, types: SchemaTypeName[], auth?: AuthContext): Promise<Schema>;
+    /** List custom-entity definitions. `expandSchemas` inlines each schema body. */
+    listCustomEntities(opts?: ListCustomEntitiesOptions, auth?: AuthContext): Promise<CustomEntity[]>;
+    /** Retrieve one custom-entity definition by id. */
+    getCustomEntity(id: string, auth?: AuthContext): Promise<CustomEntity>;
+    /** Create a custom-entity definition. */
+    createCustomEntity(draft: CustomEntityDraft, auth?: AuthContext): Promise<CustomEntity>;
+    /** Update a custom-entity definition. */
+    updateCustomEntity(id: string, draft: CustomEntityDraft, auth?: AuthContext): Promise<CustomEntity>;
+    /**
+     * Delete a custom-entity definition. The server rejects with 409 if
+     * instances or schemas still reference it (propagated as the standard
+     * conflict error).
+     */
+    deleteCustomEntity(id: string, auth?: AuthContext): Promise<void>;
+    /**
+     * List a custom entity's instances, wrapped in {@link PaginatedItems}.
+     * `type` is the custom-entity type and is always the first argument.
+     */
+    listInstances<T = Record<string, unknown>>(type: string, query?: ListInstancesQuery, auth?: AuthContext): Promise<PaginatedItems<CustomInstance<T>>>;
+    /** Retrieve one instance by id. */
+    getInstance<T = Record<string, unknown>>(type: string, id: string, auth?: AuthContext): Promise<CustomInstance<T>>;
+    /** Create an instance of a custom entity. */
+    createInstance<T = Record<string, unknown>>(type: string, draft: CustomInstanceDraft<T>, auth?: AuthContext): Promise<CustomInstance<T>>;
+    /** Replace an instance (full `PUT`). */
+    replaceInstance<T = Record<string, unknown>>(type: string, id: string, draft: CustomInstanceDraft<T>, auth?: AuthContext): Promise<CustomInstance<T>>;
+    /** Partially update an instance (`PATCH`). */
+    patchInstance<T = Record<string, unknown>>(type: string, id: string, patch: Partial<CustomInstanceDraft<T>>, auth?: AuthContext): Promise<CustomInstance<T>>;
+    /** Delete an instance by id. */
+    deleteInstance(type: string, id: string, auth?: AuthContext): Promise<void>;
+    /**
+     * Structured search over a custom entity's instances
+     * (`POST /instances/search`), wrapped in {@link PaginatedItems}.
+     */
+    searchInstances<T = Record<string, unknown>>(type: string, body: InstanceSearchBody, auth?: AuthContext): Promise<PaginatedItems<CustomInstance<T>>>;
+}
+
+type AgenticRequest = {
+    /**
+     * Unique identifier of the agent.
+     */
+    agentId: string;
+    /**
+     * The user message to the agent.
+     */
+    message: string;
+};
+/**
+ * Type of the agent handling the request.
+ */
+type AgentType = 'support' | 'generic' | 'complaint' | 'anti_fraud';
+/**
+ * Represents a request body for a text generation operation.
+ */
+type TextGenerationRequest = {
+    /**
+     * Identifier of the request. The value is not mandatory - if provided, the ID is returned in the text generation response.
+     */
+    id?: string;
+    /**
+     * A prompt to AI engine. A desired text content is generated based on the prompt.
+     */
+    prompt: string;
+    /**
+     * Maximum number of tokens that should be used during text generation. If not provided, then 4097 is used.
+     */
+    maxTokens?: number;
+};
+type InnerTokenRequest = {
+    /**
+     * ID of the token.
+     */
+    id: string;
+};
+type InnerTokenResponse = {
+    /**
+     * ID of the token.
+     */
+    id?: string;
+};
+type ExpandedTokenResponse = InnerTokenResponse & {
+    /**
+     * Name of the token.
+     */
+    name?: string;
+    metadata?: MetadataResponse;
+};
+/**
+ * The full response representing token. If the `expand=token` is **not** used, then only `id` field is returned, otherwise all fields are returned.
+ */
+type ExpandableTokenResponse = InnerTokenResponse | ExpandedTokenResponse;
+/**
+ * Type of the native tool.
+ */
+type NativeToolType = 'slack' | 'rag_custom' | 'rag_emporix';
+type BaseNativeTool = {
+    type: NativeToolType;
+    /**
+     * Name of the tool.
+     */
+    name: string;
+    /**
+     * An indicator whether the tool is enabled.
+     */
+    enabled?: boolean;
+};
+type RagCustomEmbeddingNativeToolConfig = {
+    /**
+     * Name of the OpenAI LLM model which should be used to create embedding of user's input in order to perform search operation.
+     */
+    model: string;
+};
+type RagCustomEmbeddingNativeToolConfigResponse = RagCustomEmbeddingNativeToolConfig & {
+    token?: ExpandableTokenResponse;
+};
+/**
+ * Type of the database.
+ */
+type RagCustomDatabaseType = 'qdrant';
+/**
+ * Type of the entity which is stored in the given collection.
+ */
+type RagEntityType = 'product';
+type RagCustomDatabaseNativeToolConfig = {
+    /**
+     * URL of the database.
+     */
+    url: string;
+    type: RagCustomDatabaseType;
+    entityType: RagEntityType;
+    /**
+     * Name of the database collection.
+     */
+    collectionName: string;
+};
+type RagCustomDatabaseNativeToolConfigResponse = RagCustomDatabaseNativeToolConfig & {
+    token?: ExpandableTokenResponse;
+};
+type RagCustomNativeToolConfig = {
+    /**
+     * The prompt for an agent. It should define when and why this tool is to be called.
+     */
+    prompt: string;
+    /**
+     * The maximum number of results found in the Vector Database.
+     */
+    maxResults?: number;
+};
+type RagCustomNativeToolConfigResponse = RagCustomNativeToolConfig & {
+    databaseConfig?: RagCustomDatabaseNativeToolConfigResponse;
+    embeddingConfig?: RagCustomEmbeddingNativeToolConfigResponse;
+};
+type RagLlmProvider = 'emporix_openai' | 'openai' | 'self_hosted_ollama';
+type EmporixOpenAiRagEmporixEmbeddingNativeToolConfig = {
+    /**
+     * For this type, it should be set to 'emporix_openai'.
+     */
+    provider: RagLlmProvider;
+};
+type OpenAiRagEmporixEmbeddingNativeToolConfig = {
+    /**
+     * For this type, it should be set to 'emporix_openai'.
+     */
+    provider: RagLlmProvider;
+    /**
+     * OpenAI LLM model to be used for generating embeddings for indexed products and user's input query.
+     */
+    model: string;
+    /**
+     * Number of dimensions of embedding.
+     */
+    dimensions: number;
+};
+type OpenAiRagEmporixEmbeddingNativeToolConfigResponse = OpenAiRagEmporixEmbeddingNativeToolConfig & {
+    token?: ExpandableTokenResponse;
+};
+type SelfHostedOllamaRagEmporixEmbeddingNativeToolConfig = {
+    /**
+     * For this type, it should be set to 'self_hosted_ollama'.
+     */
+    provider: RagLlmProvider;
+    /**
+     * Ollama LLM model to be used for generating embeddings for indexed products and user's input query.
+     */
+    model: string;
+    /**
+     * Number of dimensions of embedding.
+     */
+    dimensions: number;
+    /**
+     * Base URL where Ollama is hosted.
+     */
+    url: string;
+};
+type SelfHostedOllamaRagEmporixEmbeddingNativeToolConfigResponse = SelfHostedOllamaRagEmporixEmbeddingNativeToolConfig & {
+    token?: ExpandableTokenResponse;
+};
+type RagEmporixNativeToolConfig = {
+    /**
+     * The prompt for an agent. It should define when and why this tool is to be called.
+     */
+    prompt: string;
+    /**
+     * Type of the entity which is stored in the given collection. Supported predefined types: [PRODUCT] and custom entity types.
+     */
+    entityType: string;
+    /**
+     * This field specifies the fields of the given entityType that are used for generating embeddings. The provided values are then concatenated and converted to embeddings.
+     */
+    indexedFields: Array<{
+        /**
+         * It can act as an alias for the field key. For example, if the 'name.en' key is provided then its alias could be 'English Name' and that value is used in embedding input.
+         */
+        name?: string;
+        /**
+         * Unique value representing the entityType key.
+         */
+        key: string;
+    }>;
+    /**
+     * This field specifies the fields of the given entityType that are used for filtering the data before performing actual search.
+     */
+    filterFields: Array<{
+        /**
+         * It should contain the description of the field, so LLM is able to know when to use this field in order to filter the data. For enums, possible values should be specified here.
+         */
+        description?: string;
+        /**
+         * It can act as an alias for the field key.
+         */
+        name?: string;
+        /**
+         * Unique value representing the entityType key.
+         */
+        key: string;
+    }>;
+};
+type RagEmporixNativeToolConfigResponse = RagEmporixNativeToolConfig & {
+    embeddingConfig?: EmporixOpenAiRagEmporixEmbeddingNativeToolConfig | OpenAiRagEmporixEmbeddingNativeToolConfigResponse | SelfHostedOllamaRagEmporixEmbeddingNativeToolConfigResponse;
+};
+type SlackNativeToolConfigResponse = {
+    /**
+     * Unique identifier of the Slack workspace (team) associated with the request. Used to distinguish the source Slack environment when handling events or API calls.
+     */
+    teamId: string;
+};
+type SlackNativeToolResponse = BaseNativeTool & {
+    /**
+     * Unique identifier of the tool.
+     */
+    id?: string;
+    /**
+     * For SlackNativeTool it has to be set to `slack`.
+     */
+    type?: unknown;
+    config?: SlackNativeToolConfigResponse;
+    metadata?: MetadataResponse;
+};
+type RagCustomNativeToolResponse = BaseNativeTool & {
+    /**
+     * Unique identifier of the tool.
+     */
+    id?: string;
+    /**
+     * For `RagCustomNativeTool`, it has to be set to `rag_custom`.
+     */
+    type?: unknown;
+    config?: RagCustomNativeToolConfigResponse;
+    metadata?: MetadataResponse;
+};
+type RagEmporixNativeToolResponse = BaseNativeTool & {
+    /**
+     * Unique identifier of the tool.
+     */
+    id?: string;
+    /**
+     * For `RagEmporixNativeTool`, it has to be set to `rag_emporix`.
+     */
+    type?: unknown;
+    config?: RagEmporixNativeToolConfigResponse;
+    metadata?: MetadataResponse;
+};
+/**
+ * List of native tools which agents should have access to.
+ */
+type NativeToolsResponse = Array<SlackNativeToolResponse | RagCustomNativeToolResponse | RagEmporixNativeToolResponse>;
+type McpServerConfig = {
+    /**
+     * URL of the MCP server.
+     */
+    url: string;
+    /**
+     * Name of the header required for authorization, e.g. `Authorization`.
+     */
+    authorizationHeaderName?: string;
+};
+type McpServerConfigResponse = McpServerConfig & {
+    authorizationHeaderToken?: ExpandableTokenResponse;
+};
+/**
+ * An object representing customer's own implementation of the MCP server.
+ */
+type BaseMcpServer = {
+    /**
+     * Name of the MCP server.
+     */
+    name?: string;
+    /**
+     * An indicator whether the MCP server is enabled.
+     */
+    enabled?: boolean;
+    transport?: CustomMcpServerTransportType;
+};
+type McpServerResponse = BaseMcpServer & {
+    config?: McpServerConfigResponse;
+    metadata?: MetadataResponse;
+};
+/**
+ * Type of the MCP server. The `custom` type allows you to integrate with your own MCP server instance, while the `predefined` type allows you to integrate with one of the instances provided by Emporix.
+ */
+type McpServerType = 'custom' | 'predefined';
+/**
+ * Type of the communication between the agent and the MCP server. The `streamable_http` protocol is recommended, since the `sse` protocol is deprecated.
+ */
+type CustomMcpServerTransportType = 'streamable_http' | 'sse';
+type BaseAgentMcpServer = {
+    type: McpServerType;
+};
+type PredefinedAgentMcpServer = BaseAgentMcpServer & {
+    /**
+     * For the `PredefinedMcpServer` it has to be set to `predefined`.
+     */
+    type?: unknown;
+    domain?: 'customer' | 'extensibility' | 'order' | 'product' | 'frontend';
+    /**
+     * List of the tools which should be used by the agent from this particular MCP server.
+     */
+    tools?: Array<string>;
+};
+type CustomAgentMcpServerRequest = BaseAgentMcpServer & {
+    /**
+     * For `CustomMcpServer` it has to be set to `custom`.
+     */
+    type?: unknown;
+    mcpServer: {
+        /**
+         * ID of the MCP server.
+         */
+        id: string;
+    };
+};
+type CustomAgentMcpServerResponse = CustomAgentMcpServerRequest & {
+    mcpServer?: McpServerResponse & unknown;
+};
+/**
+ * List of MCP servers which agents should have access to.
+ */
+type AgentMcpServersRequest = Array<CustomAgentMcpServerRequest | PredefinedAgentMcpServer>;
+/**
+ * List of MCP servers which agents should have access to.
+ */
+type AgentMcpServersResponse = Array<CustomAgentMcpServerResponse | PredefinedAgentMcpServer>;
+type BaseLlm = {
+    /**
+     * The exact name of the model.
+     */
+    model: string;
+    /**
+     * Value between 0.1 and 1.0 (inclusive), in steps of 0.1. The lower value the more creative (but less stable) the model is.
+     */
+    temperature: 0.1 | 0.2 | 0.3 | 0.4 | 0.5 | 0.6 | 0.7 | 0.8 | 0.9 | 1;
+    /**
+     * The limit of tokens which agent can burn during one request session.
+     */
+    maxTokens: number;
+};
+type EmporixLlm = BaseLlm & {
+    /**
+     * Type of the LLM Provider. The `emporix_openai` allows using the OpenAI token provided by Emporix. The token usage is limited. When using this provider `apiKey` property can be omitted.
+     */
+    provider: 'emporix_openai';
+};
+type SelfHostedParams = {
+    /**
+     * Url of the self-hosted LLM.
+     */
+    url: string;
+    /**
+     * Name of the header required for authorization e.g. `Authorization`.
+     */
+    authorizationHeaderName?: string;
+};
+type SelfHostedParamsRequest = SelfHostedParams & {
+    [key: string]: unknown;
+} & {
+    authorizationHeaderToken?: InnerTokenRequest;
+};
+type SelfHostedParamsResponse = SelfHostedParams & {
+    authorizationHeaderToken?: ExpandableTokenResponse;
+};
+type SelfHostedLlm = BaseLlm & {
+    /**
+     * Type of the LLM Provider. The self-hosted LLM allows you to provide your own LLMs. When using this providers, the `selfHostedParams.url` property cannot be omitted.
+     */
+    provider: 'self_hosted_ollama' | 'self_hosted_vllm';
+};
+type SelfHostedLlmRequest = SelfHostedLlm & {
+    selfHostedParams: SelfHostedParamsRequest;
+};
+type SelfHostedLlmResponse = SelfHostedLlm & {
+    selfHostedParams?: SelfHostedParamsResponse;
+};
+/**
+ * Type of the LLM Provider. The supported providers allows you to provide your own API key. When using this providers, the `apiKey` property cannot be omitted.
+ */
+type ApiKeyLlmProvider = 'openai' | 'google' | 'anthropic';
+type ApiKeyLlm = BaseLlm & {
+    provider: ApiKeyLlmProvider;
+};
+type ApiKeyLlmRequest = ApiKeyLlm & {
+    token: InnerTokenRequest;
+};
+type ApiKeyLlmResponse = ApiKeyLlm & {
+    token?: ExpandableTokenResponse;
+};
+type IdWrapper = {
+    id: string;
+};
+/**
+ * List of agent collaborations which allows an agent to hand off its task to other agents.
+ */
+type AgentCollaborations = Array<{
+    /**
+     * Identifier of the agent.
+     */
+    agentId?: string;
+    /**
+     * Description of the agent collaboration.
+     */
+    description?: string;
+}>;
+/**
+ * Type of the trigger. The `slack` trigger type can be used only for `support` agent type.
+ */
+type TriggerType = 'endpoint' | 'slack';
+/**
+ * Type of the trigger.
+ */
+type CommerceEventsTriggerType = 'commerce_events';
+type AgentTrigger = {
+    type: TriggerType;
+} | {
+    type: CommerceEventsTriggerType;
+    /**
+     * Additional configuration for the trigger.
+     */
+    config: {
+        /**
+         * List of events that trigger the agent.
+         */
+        events: string;
+    };
+};
+/**
+ * Indicates whether the agent is handOff or not. HandOff agents are special types of agents which can be called by other agents through `agentCollaborations` property and their configuration is hidden.
+ */
+type HandOff = boolean;
+type BaseForAgentAndTemplateAndHandOff = {
+    /**
+     * Localized name of the agent.
+     */
+    name?: {
+        [key: string]: string;
+    };
+    /**
+     * Description of the agent.
+     */
+    description?: {
+        [key: string]: string;
+    };
+};
+type BaseForAgentAndTemplate = BaseForAgentAndTemplateAndHandOff & {
+    /**
+     * Defines which caller types are allowed to execute the agent.
+     * Authorization is evaluated with OR semantics: access is granted if the caller
+     * matches at least one configured value.
+     * If this field is missing or empty, no scope-based restriction is applied.
+     *
+     * Matching rules:
+     * - anonymous: always grants access.
+     * - customer: requires scope `ai.agentexecution_manage_own`.
+     * - employee: requires scope `ai.agentexecution_manage`.
+     * - integration: requires scope `ai.agentexecution_manage`.
+     *
+     * If no configured value matches, request is rejected with 403 Forbidden.
+     *
+     */
+    requiredScopes?: Array<'anonymous' | 'customer' | 'employee' | 'integration'>;
+    /**
+     * LLM Prompt which describes how agent should work in a detailed way, which tools it could use to solve problems etc; it can contain examples and step by step guidance.
+     */
+    userPrompt?: string;
+    /**
+     * The fa class of react icon.
+     */
+    icon?: string;
+    tags?: Array<string>;
+    /**
+     * Indicates whether the agent is enabled.
+     */
+    enabled?: boolean;
+};
+type BaseForAgentRequestAndResponse = BaseForAgentAndTemplate & {
+    triggers: Array<AgentTrigger>;
+    agentCollaborations?: AgentCollaborations;
+    /**
+     * Defines the maximum number of reasoning steps or internal calls an AI agent is allowed to perform during a single task. Helps prevent infinite loops or excessive resource usage.
+     */
+    maxRecursionLimit?: number;
+    /**
+     * Defines whether the session memory should be stored between different agent calls.
+     */
+    enabledMemory?: boolean;
+};
+type AgentRequest = BaseForAgentRequestAndResponse & {
+    /**
+     * ID of the native tools.
+     */
+    nativeTools?: Array<IdWrapper>;
+    llmConfig: EmporixLlm | ApiKeyLlmRequest | SelfHostedLlmRequest;
+    mcpServers: AgentMcpServersRequest;
+    metadata?: MetadataRequest;
+};
+type AgentResponse = BaseForAgentRequestAndResponse & {
+    /**
+     * Identifier of the agent.
+     */
+    id?: string;
+    nativeTools?: NativeToolsResponse;
+    llmConfig?: EmporixLlm | ApiKeyLlmResponse | SelfHostedLlmResponse;
+    mcpServers?: AgentMcpServersResponse;
+    handOff?: HandOff;
+    type?: AgentType;
+    /**
+     * Prompt which is inherited from the template (if agent is created based on the template). The prompt provided by the user is then concatenated with this prompt.
+     */
+    templatePrompt?: string;
+    metadata?: MetadataResponse;
+};
+type MetadataRequest = {
+    /**
+     * Version of the object. The version is required during the update operation because of the optimistic locking mechanism.
+     */
+    version: number;
+};
+type MetadataResponse = MetadataRequest & {
+    /**
+     * Date and time when the object was created. The value is approved as an ISO-8601 representation of an Instant. For example: `2022-04-31T13:18:02.379Z`
+     */
+    createdAt: string;
+    /**
+     * Date and time when the object was last modified. The value is approved as an ISO-8601 representation of an Instant. For example: `2022-04-31T13:18:02.379Z`
+     */
+    modifiedAt: string;
+};
+type CompletionRequest$1 = {
+    /**
+     * Identifier of the request. The value is not mandatory - if provided, then the ID is returned in the text generation response.
+     */
+    id?: string;
+    messages: Array<{
+        /**
+         * Specifies the role of the message. `SYSTEM` - Provides instructions or context to the AI about the conversation.   `USER` - Represents a message sent by the user.   `ASSISTANT` - Represents a message generated by the AI.
+         */
+        role: 'USER' | 'SYSTEM' | 'ASSISTANT';
+        /**
+         * Content of the message. Depending on the role parameter, it can be a background instruction, user instruction, or AI response.
+         */
+        content: string;
+    }>;
+};
+type QParamSearchBody = {
+    /**
+     * A standard query parameter is used to search for specific values.
+     *
+     * See: [Standard Practices - Query parameter](https://developer.emporix.io/api-references/standard-practices/q-param)
+     *
+     */
+    q?: string;
+};
+/**
+ * Partial update operation list.
+ */
+type PatchRequest = Array<{
+    op: 'ADD' | 'REMOVE' | 'REPLACE';
+    path: string;
+    value?: string | {
+        [key: string]: unknown;
+    };
+}>;
+
+/** Single-shot text generation request (`POST /texts`). Has `maxTokens`. */
+type TextRequest = TextGenerationRequest;
+/**
+ * Text generation response — `{ id?, result }`. The upstream schema marks
+ * `result` optional, but a 2xx text generation always returns it; the public
+ * contract guarantees `result` so callers need not null-check.
+ */
+interface TextResponse {
+    id?: string;
+    result: string;
+}
+/** One message in a completion request. `role` ∈ `USER | SYSTEM | ASSISTANT`. */
+type CompletionMessage = CompletionRequest$1["messages"][number];
+/** Chat completion request (`POST /completions`). No `maxTokens` (server-fixed model). */
+type CompletionRequest = CompletionRequest$1;
+/** Chat completion response — `{ id?, result }` (shares the text generation shape). */
+interface CompletionResponse {
+    id?: string;
+    result: string;
+}
+/** An agentic agent definition (the read/response shape, returned by every agent method). */
+type Agent = AgentResponse;
+/** The write shape for {@link AiService.upsertAgent} (`PUT /agentic/agents/{id}`). */
+type AgentInput = AgentRequest;
+/**
+ * One PATCH operation for `patchAgent`. `op` is the upstream UPPERCASE enum
+ * (`ADD | REMOVE | REPLACE`) — NOT RFC-6902 lowercase. Passed verbatim.
+ */
+type AgentPatchOp = PatchRequest[number];
+/** Request body for `POST /agentic/agents/search` (`{ q? }`). */
+type AgentSearchQuery = QParamSearchBody;
+/** Request body for `chat` / `chatAsync` — `{ agentId, message }`. */
+type ChatRequest = AgenticRequest;
+/**
+ * One synchronous chat result — `{ agentId, agentType, sessionId, message }`.
+ * The upstream schema marks every field optional and types `agentType` as an
+ * enum; the public contract surfaces the fields a successful chat always
+ * returns as required strings.
+ */
+interface ChatResponse {
+    agentId: string;
+    agentType: string;
+    sessionId: string;
+    message: string;
+}
+/** One async job acknowledgement — `{ jobId }`. */
+interface JobIdResponse {
+    jobId: string;
+}
+/** Options for {@link AiService.deleteAgent}. */
+interface DeleteAgentOptions {
+    /** Force deletion even if the agent is referenced elsewhere (`?force=true`). */
+    force?: boolean;
+}
+
+/**
+ * Emporix AI Service (`/ai-service/{tenant}/…`): text generation, chat
+ * completions, and the agentic layer (agent CRUD + synchronous/asynchronous
+ * chat). Every endpoint requires a backend-only `ai.*` scope and the
+ * **service (clientCredentials) token** — default auth: service.
+ *
+ * Server-side use only; the service token must never reach a browser. A
+ * storefront chat (scope `ai.agentexecution_manage_own`) would require a
+ * BFF / token-proxy — out of scope for this SDK.
+ *
+ * The model is server-fixed per tenant; there is no `model` parameter.
+ */
+declare class AiService {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    private base;
+    /** Generate text from a single prompt (`POST /texts`). Honors `maxTokens`. */
+    generateText(input: TextRequest, auth?: AuthContext): Promise<TextResponse>;
+    /** Run a chat completion over a message list (`POST /completions`). No `maxTokens`. */
+    complete(input: CompletionRequest, auth?: AuthContext): Promise<CompletionResponse>;
+    /** List all agentic agents. */
+    listAgents(auth?: AuthContext): Promise<Agent[]>;
+    /** Retrieve one agent by id. */
+    getAgent(id: string, auth?: AuthContext): Promise<Agent>;
+    /** Create-or-replace an agent by id (`PUT`). Takes the agent write shape. */
+    upsertAgent(id: string, agent: AgentInput, auth?: AuthContext): Promise<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.
+     */
+    patchAgent(id: string, ops: AgentPatchOp[], auth?: AuthContext): Promise<Agent>;
+    /**
+     * Delete an agent by id. Pass `{ force: true }` to delete an agent that is
+     * still referenced elsewhere (`?force=true`).
+     */
+    deleteAgent(id: string, auth?: AuthContext, opts?: DeleteAgentOptions): Promise<void>;
+    /** Server-side agent search (`POST /agentic/agents/search`). */
+    searchAgents(query: AgentSearchQuery, auth?: AuthContext): Promise<Agent[]>;
+    /**
+     * Synchronous agent chat (`POST /agentic/chat`). Returns the response
+     * ARRAY verbatim (the upstream contract is an array, not a single object).
+     */
+    chat(input: ChatRequest, auth?: AuthContext): Promise<ChatResponse[]>;
+    /**
+     * Fire-and-forget agent chat (`POST /agentic/chat-async`, HTTP 201).
+     * Returns the job-id ARRAY verbatim.
+     */
+    chatAsync(input: ChatRequest, auth?: AuthContext): Promise<JobIdResponse[]>;
+}
+
 /** The Emporix SDK entry point. One instance safely serves many concurrent shoppers. */
 declare class EmporixClient {
     readonly customers: CustomerService;
@@ -192,6 +2194,15 @@ declare class EmporixClient {
     readonly orders: OrdersService;
     readonly salesOrders: SalesOrdersService;
     readonly availability: AvailabilityService;
+    readonly tenantConfig: TenantConfigService;
+    readonly clientConfig: ClientConfigService;
+    readonly shoppingLists: ShoppingListService;
+    readonly ragIndexer: RagIndexerService;
+    readonly sequentialIds: SequentialIdService;
+    readonly fees: FeeService;
+    readonly webhooks: WebhookService;
+    readonly schemas: SchemaService;
+    readonly ai: AiService;
     /** The validated tenant this client is bound to. */
     readonly tenant: string;
     /**
@@ -218,4 +2229,4 @@ declare class EmporixClient {
     getLogLevel(service: ServiceName): LogLevel;
 }
 
-export { AuthContext, AvailabilityService, CartService, CategoryService, CheckoutService, ClientContext, CompaniesService, ContactsService, CustomerGroupsService, CustomerService, EmporixAuthError, EmporixClient, EmporixConfig, EmporixError, EmporixForbiddenError, EmporixInsufficientScopeError, EmporixNotFoundError, EmporixServerError, EmporixValidationError, LocationsService, LogLevel, MediaService, OrdersService, PaymentGatewayService, PriceService, ProductService, ResolvedConfig, SalesOrdersService, SegmentService, ServiceName, type SessionContext, type SessionContextPatch, SessionContextService, type Site, SiteService, TokenProvider, errorFromResponse };
+export { type Agent, type AgentInput, type AgentPatchOp, type AgentSearchQuery, AiService, AuthContext, AvailabilityService, type BatchNextIdEntry, CartService, CategoryService, type ChatRequest, type ChatResponse, CheckoutService, ClientConfigService, type ClientConfiguration, ClientContext, CompaniesService, type CompletionMessage, type CompletionRequest, type CompletionResponse, type Configuration$1 as Configuration, type ConfigurationDraft, ContactsService, type CustomEntity, type CustomEntityDraft, type CustomInstance, type CustomInstanceDraft, CustomerGroupsService, CustomerService, type DeleteAgentOptions, type DeleteConfigOptions, EmporixAuthError, EmporixClient, EmporixConfig, EmporixError, EmporixForbiddenError, EmporixInsufficientScopeError, EmporixNotFoundError, EmporixServerError, EmporixValidationError, type Fee, type FeeDraft, FeeService, type InstanceSearchBody, type ItemFee, type ItemFeeDraft, type ItemFeeSearch, type JobIdResponse, type ListConfigOptions, type ListCustomEntitiesOptions, type ListFeesQuery, type ListInstancesQuery, type ListSchemasQuery, LocationsService, LogLevel, MediaService, type MetadataFilter, type NextIdCommandRequest, type NextIdOptions, type NextIdResponse, type NextIdsBatchRequest, type NextIdsBatchResponse, OrdersService, PaginatedItems, PaymentGatewayService, PriceService, ProductService, RagIndexerService, type RagType, ResolvedConfig, SalesOrdersService, type Schema, type SchemaAttribute, type SchemaDraft, SchemaService, type SchemaTypeName, type SchemaUpdate, SegmentService, type SequenceSchema, type SequenceSchemaCreate, SequentialIdService, ServiceName, type SessionContext, type SessionContextPatch, SessionContextService, type SetItemFeesOptions, type ShoppingList, type ShoppingListDraft, type ShoppingListItem, ShoppingListService, type Site, SiteService, TenantConfigService, type TextRequest, type TextResponse, TokenProvider, type WebhookConfig, type WebhookConfigCreated, type WebhookConfigDraft, type WebhookConfigPatch, type WebhookDashboardAccess, WebhookService, type WebhookStatistics, type WebhookStatisticsQuery, type WebhookSubscription, type WebhookSubscriptionUpdateItem, type WebhookSubscriptionUpdateResultItem, errorFromResponse };