@mcp-abap-adt/adt-clients 31.1.0 → 32.2.0

package/README.md

@@ -91,7 +91,7 @@ This package interacts with external packages **ONLY through interfaces**:
 
   | package | what this package takes from it |
   |---|---|
-  | [`@mcp-abap-adt/interfaces-adt`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-adt) `^16.0.0` | the capability atoms, every object's config, `IAdtResponse`, `IAnalyse`, `IAdtAnalyseOptions`, `IResultStrategy`, `ADT_NO_FAILURE`, `ADT_TASK_TYPE` |
+  | [`@mcp-abap-adt/interfaces-adt`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-adt) `^18.0.0` | the capability atoms, every object's config, `IAdtResponse`, `IAnalyse`, `IAdtAnalyseOptions`, `IResultStrategy`, `ADT_NO_FAILURE`, `ADT_TASK_TYPE` |
   | [`@mcp-abap-adt/interfaces-adt-connection`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-adt-connection) `^3.0.0` | `IAbapConnection`, `IAdtWireResponse`, `IAbapRequestOptions`, the connection capability atoms, `ADT_SESSION_ERROR` |
   | [`@mcp-abap-adt/interfaces-network`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-network) `^2.0.1` | `IWebSocketTransport` and its four companions, `HttpError` |
   | [`@mcp-abap-adt/interfaces-utils`](https://www.npmjs.com/package/@mcp-abap-adt/interfaces-utils) `^1.1.1` | `ILogger`, `LogLevel`, `XmlNode` |
@@ -162,7 +162,7 @@ npm install @mcp-abap-adt/adt-clients
 
 6. **AbapDebugger, AmdpDebugger, MemorySnapshots**
    - Standalone, from `@mcp-abap-adt/adt-clients/runtime` or the root: `new AbapDebugger(connection, logger, results?, { onConflict? })`
-   - One member per request, contracts `IAbapDebugger`, `IAmdpDebugger`, `IMemorySnapshots` from `@mcp-abap-adt/interfaces-adt` (contract 16 pairs with clients 31)
+   - One member per request, contracts `IAbapDebugger`, `IAmdpDebugger`, `IMemorySnapshots` from `@mcp-abap-adt/interfaces-adt` (contract 18 pairs with clients 32)
    - **The identity states its mode.** `{ debuggingMode: 'user', requestUser, terminalId, ideId }`, or `{ debuggingMode: 'terminal', terminalId, ideId }`; `attach` takes the identity, not the user. A terminal-mode listener catches a run that carries its ids: `run(target, { debuggee: { terminalId, ideId } })` sends them in `SAP-PASSPORT` (since 29.1.0)
    - **Breakpoints are replaced, not added to.** `setBreakpoints` and `syncBreakpoints` replace the identity's set, and `stopListener` deletes it: arm the whole set in one call
    - **Two sessions.** The ABAP listener holds one stateful connection; each debuggee caught is attached on a new one, routed to its application server. The AMDP debugger answers events on one session and takes commands on another
@@ -177,6 +177,8 @@ npm install @mcp-abap-adt/adt-clients
 | Behavior Definitions (BDEF) | ✅ |
 | Interfaces (INTF) | ✅ |
 | Programs (PROG) | ✅ |
+| Includes (PROG/I) | ✅ |
+| Enhancements (ENHO/XHB, ENHO/XHH, ENHS/XSB) | ✅ |
 | Function Groups (FUGR) | ✅ |
 | Function Modules (FUGR/FF) | ✅ |
 | Function Includes (FUGR/I) | ✅ |
@@ -191,6 +193,18 @@ npm install @mcp-abap-adt/adt-clients
 | Feature Toggles (FTG2/FT) | ✅ |
 | Transports (TRNS) | ✅ |
 
+`getEnhancement().updateMetadata()` writes the whole object document from
+`options.source` under the caller's lock, then the caller unlocks and activates.
+This writes BAdI spot definitions and container implementations; the result slot
+is `metadataUpdated`. See the [BAdI example](docs/usage/CLIENT_API_REFERENCE.md#enhancements-and-their-hosts).
+
+Class, program and function-group handlers also expose `readEnhancementElements`
+and `readEnhancementOptions` (`IAdtEnhancementHost`). `getInclude()` exposes
+both through `IAdtIncludeEnhancementHost`, with `context` set to the main
+program name. The default answers XML; custom result sets provide
+`enhancementElements` and `enhancementOptions`. These reads live on the hosts,
+not `AdtUtils`. See [enhancement examples](docs/usage/CLIENT_API_REFERENCE.md#enhancements-and-their-hosts).
+
 ## Quick Start
 
 ### Using AdtClient (Recommended - High-Level CRUD API)
@@ -436,7 +450,7 @@ await utils.readObjectSource('view' satisfies AdtSourceObjectType, 'ZOK_I_CDS_TE
 The `withLongPolling` parameter asks ADT to hold a read until the object is
 available, instead of answering from whatever is there right now:
 
-> **Measured caveat — do not rely on it for readiness.** On an SAP BTP trial the
+> **Measured caveat — do not rely on it for readiness.** On the ABAP Cloud system the
 > parameter changes nothing on an object read. Reading a message class straight
 > after creating it returned `404` in ~650ms **with** the flag — the same
 > latency as without it — and the server did not hold the request. The system's
@@ -860,7 +874,7 @@ everything else is not.
 
 ### Single Definition Site: the contract packages
 
-Since **7.5.0**, every contract type is **defined once**, in the contract packages — today `@mcp-abap-adt/interfaces-adt` (`^16.0.0`) for the ADT contracts and `@mcp-abap-adt/interfaces-adt-connection` (`^3.0.0`) for the connection. This package declares no copies of its own — every `IXxxConfig`, the capability atoms, the option and response types and the cross-cutting shared types all live there.
+Since **7.5.0**, every contract type is **defined once**, in the contract packages — today `@mcp-abap-adt/interfaces-adt` (`^18.0.0`) for the ADT contracts and `@mcp-abap-adt/interfaces-adt-connection` (`^3.0.0`) for the connection. This package declares no copies of its own — every `IXxxConfig`, the capability atoms, the option and response types and the cross-cutting shared types all live there.
 
 **Import them from the package that owns them:**
 
@@ -891,7 +905,7 @@ What this package exports is what it owns: the clients, the handler classes, the
 
 ### Honest capability types (since 8.0.0)
 
-`@mcp-abap-adt/interfaces-adt` has **capability atoms and nothing above them** — `IAdtCreatable`, `IAdtReadable`, `IAdtMetadataReadable`, `IAdtUpdatable`, `IAdtMetadataUpdatable`, `IAdtDeletable`, `IAdtValidatable`, `IAdtCheckable`, `IAdtActivatable`, `IAdtLockable`, `IAdtVersionable`, `IAdtTransportAware` — each covering one operation against one resource. **There is no composite.** `IAdtObject`, `IAdtCrud`, `IAdtModifiable` and `IAdtSourceObject` were removed in interfaces 29.0.0: they forced one result type on members that answer different things, and a create does not answer what a read answers. `IAdtSearchable` went in 30.0.0 — searching is not something an object does to itself, and the question already had a home in `IAdtInformationSystem.search`. A handler declares the atoms it honours, so there is nothing a composite could drift from.
+`@mcp-abap-adt/interfaces-adt` has **capability atoms and nothing above them** — `IAdtCreatable`, `IAdtReadable`, `IAdtMetadataReadable`, `IAdtUpdatable`, `IAdtMetadataUpdatable`, `IAdtDeletable`, `IAdtValidatable`, `IAdtCheckable`, `IAdtActivatable`, `IAdtLockable`, `IAdtVersionable`, `IAdtTransportAware`, `IAdtEnhancementHost`, `IAdtIncludeEnhancementHost` — each covering one operation against one resource. **There is no composite.** `IAdtObject`, `IAdtCrud`, `IAdtModifiable` and `IAdtSourceObject` were removed in interfaces 29.0.0: they forced one result type on members that answer different things, and a create does not answer what a read answers. `IAdtSearchable` went in 30.0.0 — searching is not something an object does to itself, and the question already had a home in `IAdtInformationSystem.search`. A handler declares the atoms it honours, so there is nothing a composite could drift from.
 
 Since **8.0.0**, each handler `implements` only the atoms it genuinely supports, and `AdtClient.getXxx()` return types are narrowed to match:
 
@@ -940,7 +954,7 @@ contracts (`IAbapDebugger`, `IAmdpDebugger`, `IMemorySnapshots`, 13.1.0). This
 package no longer declares or exports any contract type — every contract name it uses is
 sourced from the contract packages.
 
-> **Version pairing.** `adt-clients` 31 pairs with `interfaces-adt` 16 and `interfaces-adt-connection` 3 (the per-request `signal` and `ADT_REQUEST_ERROR` are gone), and `adt-strategies` 0.11.0 declares the same ranges. Because the types are sourced rather than copied, `@mcp-abap-adt/interfaces-adt` and `@mcp-abap-adt/interfaces-adt-connection` are hard peers of this package's public API. A major bump there implies a bump here; keep the two in step rather than letting a resolver pick a mismatched pair.
+> **Version pairing.** `adt-clients` 32 pairs with `interfaces-adt` 18 and `interfaces-adt-connection` 3 (the enhancement subtype and host contracts), and `adt-strategies` 0.12.0 declares the same ranges. Because the types are sourced rather than copied, `@mcp-abap-adt/interfaces-adt` and `@mcp-abap-adt/interfaces-adt-connection` are hard peers of this package's public API. A major bump there implies a bump here; keep the two in step rather than letting a resolver pick a mismatched pair.
 
 ### Naming Conventions
 
@@ -977,6 +991,7 @@ See [Architecture Documentation](docs/architecture/ARCHITECTURE.md#type-system-a
 One document per breaking release, each written for a consumer on the contract
 before it:
 
+- **[31.x → 32.0.0](docs/usage/MIGRATION-32.md)** — interfaces-adt 18, three enhancement subtypes, subtype-specific create fields, two new result slots for enhancement hosts, and `metadataUpdated` for enhancement document writes.
 - **[30.x → 31.0.0](docs/usage/MIGRATION-31.md)** — `interfaces-adt` 16 and
   `interfaces-adt-connection` 3: the per-request `signal`, `ADT_REQUEST_ERROR`
   and `IAdtError.refusal` are gone; code written for 30.x compiles unchanged.
@@ -1100,3 +1115,31 @@ users can replace it with their own build.
 ## Author
 
 Oleksii Kyslytsia <oleksij.kyslytsja@gmail.com>
+
+### Recording batches
+
+`AdtBatchConnection` records calls from the existing clients. Start the member
+calls, execute the queue, then await their results. Group creates before locks,
+then queue writes with the returned lock handles before unlocks;
+activate all objects with one plain `activateObjectsGroup` call. At a debugger
+stop, record step + stack + variables on the attached stateful connection.
+See [domain and debugger examples](docs/usage/BATCH.md).
+
+`execute()` also sends follow-up envelopes for requests recorded during settlement,
+including automatic 406/415 negotiation retries (up to 100 envelopes, then all
+remaining requests reject). Explicit session switches apply to the next recording;
+LOCK/UNLOCK run in stateful envelopes; other ordinary members run stateless.
+Consecutive LOCKs, consecutive UNLOCKs, and consecutive stateless requests each
+form separate envelopes sent in queue order.
+Execution returns the last outer response. An envelope failure stops sending and
+rejects unsent requests with a clear library error; inner HTTP failures remain
+per-part failures. The wrapped session mode is restored after execution.
+
+```typescript
+import { AdtBatchConnection, AdtClient } from '@mcp-abap-adt/adt-clients';
+
+const batch = new AdtBatchConnection(connection, { endpoint: 'communication' });
+const pending = new AdtClient(batch).getDomain().readMetadata({ domainName: 'Z_DOMAIN' });
+await batch.execute();
+const answer = await pending;
+```

package/dist/batch/AdtBatchConnection.d.ts

@@ -0,0 +1,29 @@
+import type { IAbapConnection, IAbapRequestOptions, IAdtWireResponse } from '@mcp-abap-adt/interfaces-adt-connection';
+import type { ILogger } from '@mcp-abap-adt/interfaces-utils';
+type Session = 'stateful' | 'stateless';
+/** Records member requests; execute also drains requests queued during settlement. */
+export declare class AdtBatchConnection implements IAbapConnection {
+    private readonly connection;
+    private readonly options;
+    private queue;
+    private session;
+    private readonly defaultSession;
+    private settlementFailure?;
+    private executing;
+    constructor(connection: IAbapConnection, options: {
+        endpoint: 'communication' | 'debugger';
+        logger?: ILogger;
+    });
+    private wrappedSession;
+    connect(): Promise<void>;
+    getBaseUrl(): Promise<string>;
+    getSessionId(): string | null;
+    setSessionType(type: Session): void;
+    getSessionType(): Session;
+    makeAdtRequest<T = unknown, D = unknown>(request: IAbapRequestOptions): Promise<IAdtWireResponse<T, D>>;
+    private envelopeKey;
+    /** Empty queues return a synthetic 204, data '', without network traffic. */
+    execute(): Promise<IAdtWireResponse>;
+}
+export {};
+//# sourceMappingURL=AdtBatchConnection.d.ts.map

package/dist/batch/AdtBatchConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AdtBatchConnection.d.ts","sourceRoot":"","sources":["../../src/batch/AdtBatchConnection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAI9D,KAAK,OAAO,GAAG,UAAU,GAAG,WAAW,CAAC;AAQxC,sFAAsF;AACtF,qBAAa,kBAAmB,YAAW,eAAe;IAOtD,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,OAAO,CAAC,KAAK,CAAiB;IAC9B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAU;IACzC,OAAO,CAAC,iBAAiB,CAAC,CAAqB;IAC/C,OAAO,CAAC,SAAS,CAAS;gBAEP,UAAU,EAAE,eAAe,EAC3B,OAAO,EAAE;QACxB,QAAQ,EAAE,eAAe,GAAG,UAAU,CAAC;QACvC,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB;IAQH,OAAO,CAAC,cAAc;IAWtB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAGxB,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAG7B,YAAY,IAAI,MAAM,GAAG,IAAI;IAG7B,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAGnC,cAAc,IAAI,OAAO;IAGzB,cAAc,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO,EACrC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAuBlC,OAAO,CAAC,WAAW;IAkBnB,6EAA6E;IACvE,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;CAuF3C"}

package/dist/batch/AdtBatchConnection.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdtBatchConnection = void 0;
+const objects_1 = require("../endpoints/objects");
+const wire_1 = require("./wire");
+/** Records member requests; execute also drains requests queued during settlement. */
+class AdtBatchConnection {
+    connection;
+    options;
+    queue = [];
+    session;
+    defaultSession;
+    settlementFailure;
+    executing = false;
+    constructor(connection, options) {
+        this.connection = connection;
+        this.options = options;
+        // Debugger requests use the attached stateful session; communication
+        // members opt into stateful mode only for their own LOCK or UNLOCK.
+        this.defaultSession =
+            options.endpoint === 'debugger' ? 'stateful' : 'stateless';
+        this.session = this.defaultSession;
+    }
+    wrappedSession() {
+        const connection = this.connection;
+        return (connection.getSessionType?.() ??
+            connection.getSessionMode?.() ??
+            'stateless');
+    }
+    connect() {
+        return this.connection.connect();
+    }
+    getBaseUrl() {
+        return this.connection.getBaseUrl();
+    }
+    getSessionId() {
+        return this.connection.getSessionId();
+    }
+    setSessionType(type) {
+        this.session = type;
+    }
+    getSessionType() {
+        return this.session;
+    }
+    makeAdtRequest(request) {
+        if (this.settlementFailure)
+            return Promise.reject(this.settlementFailure.error);
+        const headers = { ...request.headers };
+        const stateful = this.session === 'stateful' ||
+            Object.entries(headers).some(([key, value]) => key.toLowerCase() === 'x-sap-adt-sessiontype' && value === 'stateful');
+        // Members restore their mode only after the deferred answer. Scope an
+        // explicit switch to this recording so neighbouring members cannot inherit it.
+        this.session = this.defaultSession;
+        if (stateful)
+            headers['X-sap-adt-sessiontype'] = 'stateful';
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                request: { ...request, headers },
+                stateful,
+                resolve,
+                reject,
+            });
+        });
+    }
+    envelopeKey(part) {
+        if (!part.stateful)
+            return 'stateless';
+        if (this.options.endpoint === 'debugger')
+            return 'stateful';
+        const action = new URL(part.request.url, 'https://batch.invalid').searchParams.get('_action') ??
+            new URLSearchParams(part.request.params).get('_action');
+        if (action === 'LOCK')
+            return 'lock';
+        if (action === 'UNLOCK')
+            return 'unlock';
+        // Communication members currently use stateful mode only for LOCK/UNLOCK.
+        // Keep any future other stateful requests in their own consecutive group.
+        return 'stateful';
+    }
+    /** Empty queues return a synthetic 204, data '', without network traffic. */
+    async execute() {
+        if (this.executing)
+            throw new Error('An ADT batch execute is already in progress');
+        const pending = this.queue;
+        this.queue = [];
+        if (!pending.length)
+            return { status: 204, statusText: 'Empty batch', headers: {}, data: '' };
+        this.executing = true;
+        const previous = this.wrappedSession();
+        let active = [];
+        try {
+            let response;
+            for (let envelope = 0;; envelope++) {
+                if (envelope === 100)
+                    throw new Error('ADT batch exceeded 100 settlement envelopes');
+                const key = this.envelopeKey(pending[0]);
+                const nextMode = pending.findIndex((part) => this.envelopeKey(part) !== key);
+                active = pending.splice(0, nextMode < 0 ? pending.length : nextMode);
+                const payload = (0, wire_1.buildBatchPayload)(active.map((part) => (0, wire_1.innerRequest)(part.request)));
+                this.connection.setSessionType(active[0].stateful ? 'stateful' : 'stateless');
+                this.options.logger?.debug('Executing ADT batch', {
+                    endpoint: this.options.endpoint,
+                    parts: active.length,
+                });
+                response = await this.connection.makeAdtRequest({
+                    url: objects_1.BATCH[this.options.endpoint],
+                    method: 'POST',
+                    timeout: 0,
+                    data: payload.body,
+                    headers: {
+                        'Content-Type': `multipart/mixed; boundary=${payload.boundary}`,
+                        Accept: 'multipart/mixed',
+                    },
+                });
+                const parts = (0, wire_1.parseBatchResponse)(response);
+                for (const [index, part] of active.entries()) {
+                    const answer = parts[index];
+                    if (!answer)
+                        part.reject(new Error(`ADT batch response part count mismatch: expected ${active.length}, received ${parts.length}; missing part ${index + 1}`));
+                    else if (answer.status >= 200 && answer.status < 300)
+                        part.resolve(answer);
+                    else
+                        part.reject(Object.assign(new Error(`Request failed with status code ${answer.status}`), { response: answer }));
+                }
+                if (parts.length !== active.length)
+                    throw new Error(`ADT batch response part count mismatch: expected ${active.length}, received ${parts.length}`);
+                active = [];
+                // Let negotiation and member continuations record their follow-up calls.
+                await new Promise((resolve) => setImmediate(resolve));
+                pending.push(...this.queue.splice(0));
+                if (!pending.length)
+                    return response;
+            }
+        }
+        catch (error) {
+            const unsentError = new Error('ADT batch request not sent because an earlier batch envelope failed', { cause: error });
+            this.settlementFailure = { error: unsentError };
+            for (const part of active)
+                part.reject(error);
+            for (const part of pending)
+                part.reject(unsentError);
+            await new Promise((resolve) => setImmediate(resolve));
+            for (const part of this.queue.splice(0))
+                part.reject(unsentError);
+            await new Promise((resolve) => setImmediate(resolve));
+            throw error;
+        }
+        finally {
+            this.connection.setSessionType(previous);
+            this.executing = false;
+            this.settlementFailure = undefined;
+        }
+    }
+}
+exports.AdtBatchConnection = AdtBatchConnection;

package/dist/batch/index.d.ts

@@ -0,0 +1,2 @@
+export { AdtBatchConnection } from './AdtBatchConnection';
+//# sourceMappingURL=index.d.ts.map

package/dist/batch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/batch/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/batch/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdtBatchConnection = void 0;
+var AdtBatchConnection_1 = require("./AdtBatchConnection");
+Object.defineProperty(exports, "AdtBatchConnection", { enumerable: true, get: function () { return AdtBatchConnection_1.AdtBatchConnection; } });

package/dist/batch/wire.d.ts

@@ -0,0 +1,10 @@
+import type { IAbapRequestOptions, IAdtWireResponse } from '@mcp-abap-adt/interfaces-adt-connection';
+export declare const createBatchBoundary: () => string;
+export declare const createRequestId: () => string;
+export declare function buildBatchPayload(requests: readonly string[], boundary?: string): {
+    boundary: string;
+    body: string;
+};
+export declare function innerRequest(request: IAbapRequestOptions): string;
+export declare function parseBatchResponse(response: IAdtWireResponse): IAdtWireResponse[];
+//# sourceMappingURL=wire.d.ts.map

package/dist/batch/wire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wire.d.ts","sourceRoot":"","sources":["../../src/batch/wire.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAEjD,eAAO,MAAM,mBAAmB,QAAO,MAAiC,CAAC;AACzE,eAAO,MAAM,eAAe,QAAO,MAAwC,CAAC;AAE5E,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,QAAQ,SAAwB,GAC/B;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAWpC;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,MAAM,CAqBjE;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,gBAAgB,GACzB,gBAAgB,EAAE,CAyDpB"}

package/dist/batch/wire.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRequestId = exports.createBatchBoundary = void 0;
+exports.buildBatchPayload = buildBatchPayload;
+exports.innerRequest = innerRequest;
+exports.parseBatchResponse = parseBatchResponse;
+const node_crypto_1 = require("node:crypto");
+const createBatchBoundary = () => `batch_${(0, node_crypto_1.randomUUID)()}`;
+exports.createBatchBoundary = createBatchBoundary;
+const createRequestId = () => (0, node_crypto_1.randomUUID)().replace(/-/g, '');
+exports.createRequestId = createRequestId;
+function buildBatchPayload(requests, boundary = (0, exports.createBatchBoundary)()) {
+    return {
+        boundary,
+        body: requests
+            .map((request) => `--${boundary}\r\nContent-Type: application/http\r\ncontent-transfer-encoding: binary\r\n\r\n${request}`)
+            .join('') + `\r\n--${boundary}--\r\n`,
+    };
+}
+function innerRequest(request) {
+    const headers = { ...request.headers };
+    // `data: null` is how a member says "no body" (lock, unlock): it must not
+    // become the four characters "null". Sent that way, every PUT under those
+    // locks was refused 423 "invalid lock handle" (on an on-premise system, 2026-10-16).
+    const hasBody = request.data !== undefined && request.data !== null;
+    const body = hasBody ? String(request.data) : '';
+    if (hasBody) {
+        for (const key of Object.keys(headers))
+            if (key.toLowerCase() === 'content-length')
+                delete headers[key];
+        headers['Content-Length'] = String(Buffer.byteLength(body));
+    }
+    const params = request.params
+        ? new URLSearchParams(request.params).toString()
+        : '';
+    const url = request.url +
+        (params ? `${request.url.includes('?') ? '&' : '?'}${params}` : '');
+    return `${request.method} ${url} HTTP/1.1\r\n${Object.entries(headers)
+        .map(([key, value]) => `${key}: ${value}\r\n`)
+        .join('')}\r\n${body}\r\n`;
+}
+function parseBatchResponse(response) {
+    const contentType = Object.entries(response.headers).find(([key]) => key.toLowerCase() === 'content-type')?.[1];
+    const boundary = /boundary=(?:"([^"]+)"|([^;\s]+))/i.exec(String(contentType));
+    if (!boundary)
+        throw new Error('Invalid ADT batch response: missing multipart boundary');
+    const escaped = (boundary[1] ?? boundary[2]).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Only complete delimiter lines count; boundary-like body text is payload.
+    const delimiter = new RegExp(`(?:^|\\r?\\n)--${escaped}(--)?[ \t]*(?:\\r?\\n|$)`, 'g');
+    const body = String(response.data);
+    const chunks = [];
+    let start;
+    for (const match of body.matchAll(delimiter)) {
+        if (start !== undefined)
+            chunks.push(body.slice(start, match.index));
+        if (match[1])
+            break;
+        start = match.index + match[0].length;
+    }
+    return chunks.map((part) => {
+        const match = /(?:^|\r?\n)HTTP\/1\.\d\s+(\d{3})\s*([^\r\n]*)\r?\n/.exec(part);
+        if (!match || match.index === undefined)
+            throw new Error('Invalid ADT batch response: missing inner HTTP status');
+        const rest = part.slice(match.index + match[0].length);
+        // A bodyless answer (an UNLOCK's 200) ends right after its headers: the
+        // empty line's last CRLF belongs to the next delimiter (RFC 2046), so the
+        // part holds one line break, not two. Headers then run to the end.
+        // Immediately after the status line, one blank line means no headers.
+        const found = /^(?:\r?\n)|\r?\n\r?\n/.exec(rest);
+        const split = found && found.index !== undefined
+            ? { index: found.index, length: found[0].length }
+            : { index: rest.length, length: 0 };
+        const headers = {};
+        for (const line of rest.slice(0, split.index).split(/\r?\n/)) {
+            const colon = line.indexOf(':');
+            if (colon > 0)
+                headers[line.slice(0, colon).toLowerCase()] = line
+                    .slice(colon + 1)
+                    .trim();
+        }
+        return {
+            status: Number(match[1]),
+            statusText: match[2].trim(),
+            headers,
+            data: rest.slice(split.index + split.length),
+        };
+    });
+}

package/dist/clients/AdtClient.d.ts

@@ -12,7 +12,7 @@
  * Each factory method returns an IAdtObject instance that can be used
  * to perform operations on a specific object type.
  */
-import type { IAdtActivatable, IAdtCheckable, IAdtClientOptions, IAdtContentTypes, IAdtCreatable, IAdtDataPreview, IAdtDeletable, IAdtDiscovery, IAdtGroupLifecycle, IAdtInformationSystem, IAdtLockable, IAdtMetadataReadable, IAdtMetadataUpdatable, IAdtObjectAccess, IAdtReadable, IAdtRepositoryStructure, IAdtRequest, IAdtServiceBindingTypes, IAdtServiceGroupReadable, IAdtSystemContext, IAdtTransportAware, IAdtTransportMoveObjects, IAdtTransportObjectActions, IAdtTransportSearchConfigurations, IAdtTransportSortAndCompress, IAdtUpdatable, IAdtValidatable, IAdtVersionable, ICdsTestDoubleCheckable, IFeatureToggleObject, IIncludeConfig, IServiceBindingConfig } from '@mcp-abap-adt/interfaces-adt';
+import type { IAdtActivatable, IAdtCheckable, IAdtClientOptions, IAdtContentTypes, IAdtCreatable, IAdtDataPreview, IAdtDeletable, IAdtDiscovery, IAdtEnhancementHost, IAdtGroupLifecycle, IAdtIncludeEnhancementHost, IAdtInformationSystem, IAdtLockable, IAdtMetadataReadable, IAdtMetadataUpdatable, IAdtObjectAccess, IAdtReadable, IAdtRepositoryStructure, IAdtRequest, IAdtServiceBindingTypes, IAdtServiceGroupReadable, IAdtSystemContext, IAdtTransportAware, IAdtTransportMoveObjects, IAdtTransportObjectActions, IAdtTransportSearchConfigurations, IAdtTransportSortAndCompress, IAdtUpdatable, IAdtValidatable, IAdtVersionable, ICdsTestDoubleCheckable, IFeatureToggleObject, IIncludeConfig, IServiceBindingConfig } from '@mcp-abap-adt/interfaces-adt';
 import type { IAbapConnection } from '@mcp-abap-adt/interfaces-adt-connection';
 import type { ILogger } from '@mcp-abap-adt/interfaces-utils';
 import { accessControlDocuments, type IAccessControlConfig, type IAccessControlResults } from '../core/accessControl';
@@ -60,9 +60,9 @@ import { type ITransportConfig, type ITransportResults, transportDocuments } fro
  * disagreement is no longer expressible. `capabilities/shape.ts` checks these
  * against the manifest.
  */
-export type IClassContract<R extends IClassResults> = IAdtCreatable<IClassConfig, ReturnType<R['created']>> & IAdtReadable<IClassConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IClassConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IClassConfig>, ReturnType<R['updated']>> & IAdtDeletable<IClassConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IClassConfig, ReturnType<R['validation']>> & IAdtCheckable<IClassConfig, ReturnType<R['check']>> & IAdtActivatable<IClassConfig, ReturnType<R['activation']>> & IAdtLockable<IClassConfig> & IAdtTransportAware<IClassConfig, string> & IAdtVersionable<IClassConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
-export type IProgramContract<R extends IProgramResults> = IAdtCreatable<IProgramConfig, ReturnType<R['created']>> & IAdtReadable<IProgramConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IProgramConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IProgramConfig>, ReturnType<R['updated']>> & IAdtDeletable<IProgramConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IProgramConfig, ReturnType<R['validation']>> & IAdtCheckable<IProgramConfig, ReturnType<R['check']>> & IAdtActivatable<IProgramConfig, ReturnType<R['activation']>> & IAdtLockable<IProgramConfig> & IAdtTransportAware<IProgramConfig, ReturnType<R['transport']>> & IAdtVersionable<IProgramConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
-export type IIncludeContract<R extends IIncludeResults> = IAdtCreatable<IIncludeConfig, ReturnType<R['created']>> & IAdtReadable<IIncludeConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IIncludeConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IIncludeConfig>, ReturnType<R['updated']>> & IAdtDeletable<IIncludeConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IIncludeConfig, ReturnType<R['validation']>> & IAdtActivatable<IIncludeConfig, ReturnType<R['activation']>> & IAdtLockable<IIncludeConfig>;
+export type IClassContract<R extends IClassResults> = IAdtCreatable<IClassConfig, ReturnType<R['created']>> & IAdtReadable<IClassConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IClassConfig, ReturnType<R['metadata']>> & IAdtEnhancementHost<IClassConfig, ReturnType<R['enhancementElements']>, ReturnType<R['enhancementOptions']>> & IAdtUpdatable<Partial<IClassConfig>, ReturnType<R['updated']>> & IAdtDeletable<IClassConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IClassConfig, ReturnType<R['validation']>> & IAdtCheckable<IClassConfig, ReturnType<R['check']>> & IAdtActivatable<IClassConfig, ReturnType<R['activation']>> & IAdtLockable<IClassConfig> & IAdtTransportAware<IClassConfig, string> & IAdtVersionable<IClassConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
+export type IProgramContract<R extends IProgramResults> = IAdtCreatable<IProgramConfig, ReturnType<R['created']>> & IAdtReadable<IProgramConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IProgramConfig, ReturnType<R['metadata']>> & IAdtEnhancementHost<IProgramConfig, ReturnType<R['enhancementElements']>, ReturnType<R['enhancementOptions']>> & IAdtUpdatable<Partial<IProgramConfig>, ReturnType<R['updated']>> & IAdtDeletable<IProgramConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IProgramConfig, ReturnType<R['validation']>> & IAdtCheckable<IProgramConfig, ReturnType<R['check']>> & IAdtActivatable<IProgramConfig, ReturnType<R['activation']>> & IAdtLockable<IProgramConfig> & IAdtTransportAware<IProgramConfig, ReturnType<R['transport']>> & IAdtVersionable<IProgramConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
+export type IIncludeContract<R extends IIncludeResults> = IAdtCreatable<IIncludeConfig, ReturnType<R['created']>> & IAdtReadable<IIncludeConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IIncludeConfig, ReturnType<R['metadata']>> & IAdtIncludeEnhancementHost<IIncludeConfig, ReturnType<R['enhancementElements']>, ReturnType<R['enhancementOptions']>> & IAdtUpdatable<Partial<IIncludeConfig>, ReturnType<R['updated']>> & IAdtDeletable<IIncludeConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IIncludeConfig, ReturnType<R['validation']>> & IAdtActivatable<IIncludeConfig, ReturnType<R['activation']>> & IAdtLockable<IIncludeConfig>;
 export type IInterfaceContract<R extends IInterfaceResults> = IAdtCreatable<IInterfaceConfig, ReturnType<R['created']>> & IAdtReadable<IInterfaceConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IInterfaceConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IInterfaceConfig>, ReturnType<R['updated']>> & IAdtDeletable<IInterfaceConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IInterfaceConfig, ReturnType<R['validation']>> & IAdtCheckable<IInterfaceConfig, ReturnType<R['check']>> & IAdtActivatable<IInterfaceConfig, ReturnType<R['activation']>> & IAdtLockable<IInterfaceConfig> & IAdtTransportAware<IInterfaceConfig, ReturnType<R['transport']>> & IAdtVersionable<IInterfaceConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 export type IDomainContract<R extends IDomainResults> = IAdtCreatable<IDomainConfig, ReturnType<R['created']>> & IAdtMetadataReadable<IDomainConfig, ReturnType<R['metadata']>> & IAdtMetadataUpdatable<Partial<IDomainConfig>, ReturnType<R['metadataUpdated']>> & IAdtDeletable<IDomainConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IDomainConfig, ReturnType<R['validation']>> & IAdtCheckable<IDomainConfig, ReturnType<R['check']>> & IAdtActivatable<IDomainConfig, ReturnType<R['activation']>> & IAdtLockable<IDomainConfig> & IAdtTransportAware<IDomainConfig, ReturnType<R['transport']>>;
 export type IDataElementContract<R extends IDataElementResults> = IAdtCreatable<IDataElementConfig, ReturnType<R['created']>> & IAdtMetadataReadable<IDataElementConfig, ReturnType<R['metadata']>> & IAdtMetadataUpdatable<Partial<IDataElementConfig>, ReturnType<R['metadataUpdated']>> & IAdtDeletable<IDataElementConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IDataElementConfig, ReturnType<R['validation']>> & IAdtCheckable<IDataElementConfig, ReturnType<R['check']>> & IAdtActivatable<IDataElementConfig, ReturnType<R['activation']>> & IAdtLockable<IDataElementConfig> & IAdtTransportAware<IDataElementConfig, ReturnType<R['transport']>>;
@@ -71,7 +71,7 @@ export type IStructureContract<R extends IStructureResults> = IAdtCreatable<IStr
 export type ITableContract<R extends ITableResults> = IAdtCreatable<ITableConfig, ReturnType<R['created']>> & IAdtReadable<ITableConfig, ReturnType<R['source']>> & IAdtMetadataReadable<ITableConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<ITableConfig>, ReturnType<R['updated']>> & IAdtDeletable<ITableConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<ITableConfig, ReturnType<R['validation']>> & IAdtCheckable<ITableConfig, ReturnType<R['check']>> & IAdtActivatable<ITableConfig, ReturnType<R['activation']>> & IAdtLockable<ITableConfig> & IAdtTransportAware<ITableConfig, ReturnType<R['transport']>> & IAdtVersionable<ITableConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 export type ITableTypeContract<R extends ITableTypeResults> = IAdtCreatable<ITableTypeConfig, ReturnType<R['created']>> & IAdtMetadataReadable<ITableTypeConfig, ReturnType<R['metadata']>> & IAdtMetadataUpdatable<Partial<ITableTypeConfig>, ReturnType<R['metadataUpdated']>> & IAdtDeletable<ITableTypeConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<ITableTypeConfig, ReturnType<R['validation']>> & IAdtCheckable<ITableTypeConfig, ReturnType<R['check']>> & IAdtActivatable<ITableTypeConfig, ReturnType<R['activation']>> & IAdtLockable<ITableTypeConfig> & IAdtTransportAware<ITableTypeConfig, ReturnType<R['transport']>> & IAdtVersionable<ITableTypeConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 export type IDdlContract<R extends IDdlResults> = IAdtCreatable<IDdlConfig, ReturnType<R['created']>> & IAdtReadable<IDdlConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IDdlConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IDdlConfig>, ReturnType<R['updated']>> & IAdtDeletable<IDdlConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IDdlConfig, ReturnType<R['validation']>> & IAdtCheckable<IDdlConfig, ReturnType<R['check']>> & IAdtActivatable<IDdlConfig, ReturnType<R['activation']>> & IAdtLockable<IDdlConfig> & IAdtTransportAware<IDdlConfig, ReturnType<R['transport']>> & IAdtVersionable<IDdlConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>> & ICdsTestDoubleCheckable<ReturnType<R['testDoubles']>>;
-export type IFunctionGroupContract<R extends IFunctionGroupResults> = IAdtCreatable<IFunctionGroupConfig, ReturnType<R['created']>> & IAdtMetadataReadable<IFunctionGroupConfig, ReturnType<R['metadata']>> & IAdtMetadataUpdatable<Partial<IFunctionGroupConfig>, ReturnType<R['metadataUpdated']>> & IAdtDeletable<IFunctionGroupConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IFunctionGroupConfig, ReturnType<R['validation']>> & IAdtCheckable<IFunctionGroupConfig, ReturnType<R['check']>> & IAdtActivatable<IFunctionGroupConfig, ReturnType<R['activation']>> & IAdtLockable<IFunctionGroupConfig> & IAdtTransportAware<IFunctionGroupConfig, ReturnType<R['transport']>>;
+export type IFunctionGroupContract<R extends IFunctionGroupResults> = IAdtCreatable<IFunctionGroupConfig, ReturnType<R['created']>> & IAdtMetadataReadable<IFunctionGroupConfig, ReturnType<R['metadata']>> & IAdtEnhancementHost<IFunctionGroupConfig, ReturnType<R['enhancementElements']>, ReturnType<R['enhancementOptions']>> & IAdtMetadataUpdatable<Partial<IFunctionGroupConfig>, ReturnType<R['metadataUpdated']>> & IAdtDeletable<IFunctionGroupConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IFunctionGroupConfig, ReturnType<R['validation']>> & IAdtCheckable<IFunctionGroupConfig, ReturnType<R['check']>> & IAdtActivatable<IFunctionGroupConfig, ReturnType<R['activation']>> & IAdtLockable<IFunctionGroupConfig> & IAdtTransportAware<IFunctionGroupConfig, ReturnType<R['transport']>>;
 export type IFunctionModuleContract<R extends IFunctionModuleResults> = IAdtCreatable<IFunctionModuleConfig, ReturnType<R['created']>> & IAdtReadable<IFunctionModuleConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IFunctionModuleConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IFunctionModuleConfig>, ReturnType<R['updated']>> & IAdtDeletable<IFunctionModuleConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IFunctionModuleConfig, ReturnType<R['validation']>> & IAdtCheckable<IFunctionModuleConfig, ReturnType<R['check']>> & IAdtActivatable<IFunctionModuleConfig, ReturnType<R['activation']>> & IAdtLockable<IFunctionModuleConfig> & IAdtTransportAware<IFunctionModuleConfig, ReturnType<R['transport']>> & IAdtVersionable<IFunctionModuleConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 export type IFunctionIncludeContract<R extends IFunctionIncludeResults> = IAdtCreatable<IFunctionIncludeConfig, ReturnType<R['created']>> & IAdtReadable<IFunctionIncludeConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IFunctionIncludeConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IFunctionIncludeConfig>, ReturnType<R['updated']>> & IAdtMetadataUpdatable<Partial<IFunctionIncludeConfig>, ReturnType<R['metadataUpdated']>> & IAdtDeletable<IFunctionIncludeConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IFunctionIncludeConfig, ReturnType<R['validation']>> & IAdtCheckable<IFunctionIncludeConfig, ReturnType<R['check']>> & IAdtActivatable<IFunctionIncludeConfig, ReturnType<R['activation']>> & IAdtLockable<IFunctionIncludeConfig> & IAdtVersionable<IFunctionIncludeConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 export type IPackageContract<R extends IPackageResults> = IAdtCreatable<IPackageConfig, ReturnType<R['created']>> & IAdtMetadataReadable<IPackageConfig, ReturnType<R['metadata']>> & IAdtMetadataUpdatable<Partial<IPackageConfig>, ReturnType<R['metadataUpdated']>> & IAdtDeletable<IPackageConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IPackageConfig, ReturnType<R['validation']>> & IAdtCheckable<IPackageConfig, ReturnType<R['check']>> & IAdtLockable<IPackageConfig> & IAdtTransportAware<IPackageConfig, ReturnType<R['transport']>>;
@@ -109,7 +109,7 @@ export type IAppendStructureContract<R extends IAppendStructureResults> = IAdtCr
 export type IBehaviorDefinitionContract<R extends IBehaviorDefinitionResults> = IAdtCreatable<IBehaviorDefinitionConfig, ReturnType<R['created']>> & IAdtReadable<IBehaviorDefinitionConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IBehaviorDefinitionConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IBehaviorDefinitionConfig>, ReturnType<R['updated']>> & IAdtDeletable<IBehaviorDefinitionConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IBehaviorDefinitionConfig, ReturnType<R['validation']>> & IAdtCheckable<IBehaviorDefinitionConfig, ReturnType<R['check']>> & IAdtActivatable<IBehaviorDefinitionConfig, ReturnType<R['activation']>> & IAdtLockable<IBehaviorDefinitionConfig> & IAdtTransportAware<IBehaviorDefinitionConfig, ReturnType<R['transport']>> & IAdtVersionable<IBehaviorDefinitionConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 export type IBehaviorImplementationContract<R extends IClassResults> = IAdtCreatable<IBehaviorImplementationConfig, ReturnType<R['created']>> & IAdtReadable<IBehaviorImplementationConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IBehaviorImplementationConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IBehaviorImplementationConfig>, ReturnType<R['updated']>> & IAdtDeletable<IBehaviorImplementationConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IBehaviorImplementationConfig, ReturnType<R['validation']>> & IAdtCheckable<IBehaviorImplementationConfig, ReturnType<R['check']>> & IAdtActivatable<IBehaviorImplementationConfig, ReturnType<R['activation']>> & IAdtLockable<IBehaviorImplementationConfig> & IAdtTransportAware<IBehaviorImplementationConfig, string> & IAdtVersionable<IBehaviorImplementationConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 export type IMetadataExtensionContract<R extends IMetadataExtensionResults> = IAdtCreatable<IMetadataExtensionConfig, ReturnType<R['created']>> & IAdtReadable<IMetadataExtensionConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IMetadataExtensionConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IMetadataExtensionConfig>, ReturnType<R['updated']>> & IAdtDeletable<IMetadataExtensionConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IMetadataExtensionConfig, ReturnType<R['validation']>> & IAdtCheckable<IMetadataExtensionConfig, ReturnType<R['check']>> & IAdtActivatable<IMetadataExtensionConfig, ReturnType<R['activation']>> & IAdtLockable<IMetadataExtensionConfig> & IAdtTransportAware<IMetadataExtensionConfig, ReturnType<R['transport']>> & IAdtVersionable<IMetadataExtensionConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
-export type IEnhancementContract<R extends IEnhancementResults> = IAdtCreatable<IEnhancementConfig, ReturnType<R['created']>> & IAdtReadable<IEnhancementConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IEnhancementConfig, ReturnType<R['metadata']>> & IAdtUpdatable<Partial<IEnhancementConfig>, ReturnType<R['updated']>> & IAdtDeletable<IEnhancementConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IEnhancementConfig, ReturnType<R['validation']>> & IAdtCheckable<IEnhancementConfig, ReturnType<R['check']>> & IAdtActivatable<IEnhancementConfig, ReturnType<R['activation']>> & IAdtLockable<IEnhancementConfig> & IAdtTransportAware<IEnhancementConfig, ReturnType<R['transport']>> & IAdtVersionable<IEnhancementConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
+export type IEnhancementContract<R extends IEnhancementResults> = IAdtCreatable<IEnhancementConfig, ReturnType<R['created']>> & IAdtReadable<IEnhancementConfig, ReturnType<R['source']>> & IAdtMetadataReadable<IEnhancementConfig, ReturnType<R['metadata']>> & IAdtMetadataUpdatable<IEnhancementConfig, ReturnType<R['metadataUpdated']>> & IAdtUpdatable<Partial<IEnhancementConfig>, ReturnType<R['updated']>> & IAdtDeletable<IEnhancementConfig, ReturnType<R['deletion']>, ReturnType<R['deletionCheck']>> & IAdtValidatable<IEnhancementConfig, ReturnType<R['validation']>> & IAdtCheckable<IEnhancementConfig, ReturnType<R['check']>> & IAdtActivatable<IEnhancementConfig, ReturnType<R['activation']>> & IAdtLockable<IEnhancementConfig> & IAdtTransportAware<IEnhancementConfig, ReturnType<R['transport']>> & IAdtVersionable<IEnhancementConfig, ReturnType<R['versions']>, ReturnType<R['versionSource']>>;
 /**
  * `IAdtTransportObjectActions`, `IAbapObjectEntry` and
  * `IAdtTransportSearchConfigurations` are imported, not declared.