@mcp-abap-adt/interfaces-adt 1.0.0

package/dist/adt/IAdtInterface.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Interface ADT operation parameter interfaces (snake_case, low-level)
+ */
+import type { IAdtObjectConfig } from './IAdtObjectState';
+export interface ICreateInterfaceParams {
+    interfaceName: string;
+    description: string;
+    packageName: string;
+    transportRequest?: string;
+    masterSystem?: string;
+    responsible?: string;
+    masterLanguage?: string;
+}
+export interface IUpdateInterfaceSourceParams {
+    interface_name: string;
+    source_code: string;
+    activate?: boolean;
+}
+export interface IDeleteInterfaceParams {
+    interface_name: string;
+    transport_request?: string;
+}
+export type IInterfaceConfig = IAdtObjectConfig & {
+    interfaceName: string;
+    masterLanguage?: string;
+    packageName?: string;
+    transportRequest?: string;
+    description?: string;
+    sourceCode?: string;
+    sessionId?: string;
+    onLock?: (lockHandle: string) => void;
+};
+//# sourceMappingURL=IAdtInterface.d.ts.map

package/dist/adt/IAdtInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtInterface.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtInterface.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAKD,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,GAAG;IAChD,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC,CAAC"}

package/dist/adt/IAdtInterface.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Interface ADT operation parameter interfaces (snake_case, low-level)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adt/IAdtMessageClass.d.ts

@@ -0,0 +1,35 @@
+export interface ICreateMessageClassParams {
+    name: string;
+    description: string;
+    package_name: string;
+    transport_request?: string;
+    master_language?: string;
+}
+export interface IMessageClassConfig {
+    /** Message class name (e.g. ZMY_MSGS) */
+    name: string;
+    /** Short description */
+    description?: string;
+    /** Package name — required for create */
+    packageName?: string;
+    /** Transport request — sent as corrNr (create/update) or <del:transportNumber> (delete) for transportable packages */
+    transportRequest?: string;
+    /** Master language of the message class — defaults to 'EN' on create */
+    masterLanguage?: string;
+}
+/** Configuration for operating on a single message within a message class. */
+export interface IMessageClassMessageConfig {
+    /** Parent message class name (e.g. ZMY_MSGS) */
+    className: string;
+    /** Message number (e.g. '001') */
+    msgno: string;
+    /** Message text — required for create/update */
+    msgtext?: string;
+    /** Whether the message is self-explanatory (mc:selfexplainatory attribute) */
+    selfExplanatory?: boolean;
+    /** Long description for the message (adtcore:description attribute) */
+    description?: string;
+    /** Transport request — sent as &corrNr= on the parent-class PUT for create/update/delete (transportable packages) */
+    transportRequest?: string;
+}
+//# sourceMappingURL=IAdtMessageClass.d.ts.map

package/dist/adt/IAdtMessageClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtMessageClass.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtMessageClass.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAKD,MAAM,WAAW,mBAAmB;IAClC,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yCAAyC;IACzC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sHAAsH;IACtH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAKD,8EAA8E;AAC9E,MAAM,WAAW,0BAA0B;IACzC,gDAAgD;IAChD,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,uEAAuE;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qHAAqH;IACrH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/adt/IAdtMessageClass.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adt/IAdtMetadataExtension.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Metadata Extension ADT operation parameter interfaces (low-level)
+ */
+export interface IMetadataExtensionValidationParams {
+    name: string;
+    description: string;
+    packageName: string;
+}
+export interface IMetadataExtensionCreateParams {
+    name: string;
+    description: string;
+    packageName: string;
+    transportRequest?: string;
+    masterLanguage?: string;
+    masterSystem?: string;
+    responsible?: string;
+}
+export interface IMetadataExtensionConfig {
+    name: string;
+    description?: string;
+    packageName?: string;
+    transportRequest?: string;
+    sourceCode?: string;
+    masterLanguage?: string;
+    masterSystem?: string;
+    responsible?: string;
+    sessionId?: string;
+}
+//# sourceMappingURL=IAdtMetadataExtension.d.ts.map

package/dist/adt/IAdtMetadataExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtMetadataExtension.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtMetadataExtension.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,MAAM,WAAW,kCAAkC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAID,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/dist/adt/IAdtMetadataExtension.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Metadata Extension ADT operation parameter interfaces (low-level)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adt/IAdtObject.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Operation options, version entries and error codes shared by the capability
+ * atoms.
+ *
+ * The wide `IAdtObject` this file was named for was removed in 29.0.0; what an
+ * object can do is now stated by the atoms it declares in `IAdtCapabilities.ts`.
+ * Nothing here declares an operation — these are the pieces the atoms refer to:
+ * {@link IAdtOperationOptions} carries the strategy a caller injects,
+ * a version history's entries are the implementation's since 31.0.0, and
+ * {@link AdtObjectErrorCodes} names failures a strategy can put in
+ * {@link IAdtError.code}.
+ */
+import type { IAdtWireResponse } from '../connection/IAbapConnection';
+import type { AdtNoFailure, IAdtError } from './IAdtResponse';
+/**
+ * The codes a failure can name itself by.
+ *
+ * **No member of this contract throws** since 30.0.0 — which is about what the
+ * server's answer becomes, not about what an implementation does when its own
+ * reading fails. Every member answers
+ * {@link IAdtResponse}, so a failure comes back rather than flying past, and it
+ * is read from the contract:
+ *
+ * ```typescript
+ * const answer = await adtObject.read({ className: 'ZTEST' });
+ *
+ * if (answer.ok) {
+ *   answer.getResult().value;    // what the endpoint produced
+ * } else {
+ *   const failure = answer.getError();
+ *   failure.origin;              // 'connection' | 'refusal'
+ *   failure.message;             // what SAP said, in SAP's words
+ *   failure.code;                // one of these, when the strategy named one
+ *   failure.response;            // the answer it was read from, untouched
+ * }
+ * ```
+ *
+ * These are for the failures the contract promises in a specific place, where
+ * `origin` alone cannot tell two apart: a version resource a system does not
+ * expose is `UNSUPPORTED_OPERATION` rather than merely a refusal, and a lock
+ * another user holds is `LOCK_FAILED`. A consumer branches on the code without a
+ * cast, which until 30.0.0 they could not — the promise was made by members that
+ * threw, and the failure contract had nowhere to carry it.
+ *
+ * `code` is optional, and deliberately: what a strategy chooses is how much of a
+ * failure to fill in, not whether to be one. An implementation is free to name
+ * codes of its own beside these; this package ships no error class to narrow
+ * with, because a contract says what a thing is and shipping a class from it
+ * would make "use your own implementation" untrue for that piece.
+ *
+ * Note what is *not* among them: "not found". ADT answers a request for a
+ * missing object with **200 and an empty body** rather than a 404, so absence is
+ * not a failure this library can report on its own authority — a read-modify-write
+ * must treat it as one, since writing back what it read erases the object, while
+ * a listing must treat it as an empty list. That reading is supplied through
+ * {@link IAdtOperationOptions.analyse}.
+ */
+export declare const AdtObjectErrorCodes: {
+    /** Object not found (404) */
+    readonly OBJECT_NOT_FOUND: "ADT_OBJECT_NOT_FOUND";
+    /** Object not ready yet (400) - e.g., just created, not available for reading */
+    readonly OBJECT_NOT_READY: "ADT_OBJECT_NOT_READY";
+    /** Object validation failed */
+    readonly VALIDATION_FAILED: "ADT_VALIDATION_FAILED";
+    /** Object creation failed */
+    readonly CREATE_FAILED: "ADT_CREATE_FAILED";
+    /** Object update failed */
+    readonly UPDATE_FAILED: "ADT_UPDATE_FAILED";
+    /** Object deletion failed */
+    readonly DELETE_FAILED: "ADT_DELETE_FAILED";
+    /** Object activation failed */
+    readonly ACTIVATE_FAILED: "ADT_ACTIVATE_FAILED";
+    /** Object check failed */
+    readonly CHECK_FAILED: "ADT_CHECK_FAILED";
+    /** Lock operation failed */
+    readonly LOCK_FAILED: "ADT_LOCK_FAILED";
+    /** Unlock operation failed */
+    readonly UNLOCK_FAILED: "ADT_UNLOCK_FAILED";
+    /** Operation not supported for this object type (e.g. version history on a non-source object) */
+    readonly UNSUPPORTED_OPERATION: "ADT_UNSUPPORTED_OPERATION";
+};
+/**
+ * The caller's own reading of what counts as a failure.
+ *
+ * Handed the default's verdict **and** the answer it was reached from, so it can
+ * overrule in either direction: name a failure the default let through, or clear
+ * one it raised. Answering {@link ADT_NO_FAILURE} means "not a failure here" — a
+ * token rather than `undefined`, so that the absence of a strategy and a
+ * strategy's verdict of "fine" are not the same value.
+ *
+ * **It names its own failure type.** `IAdtFailure<TError extends IAdtError>` has
+ * carried the parameter since the failure half existed, and it never arrived
+ * anywhere, because the options pinned this return to `IAdtError`. A consumer
+ * whose strategy answered something richer got it back narrowed and had to cast
+ * at the call site — which is the one thing a parameterised failure exists to
+ * prevent.
+ *
+ * The alternative was a field per case on `IAdtError`: a message id here, a
+ * severity there, a job handle next time. A contract that grows a field for
+ * every caller's special case is worse than one that lets a caller say what
+ * their own failure is, and a consumer knows perfectly well which strategy they
+ * injected.
+ *
+ * ```typescript
+ * interface IT100Failure extends IAdtError {
+ *   readonly t100: { msgid: string; msgno: string };
+ * }
+ * const t100: IAnalyse<IT100Failure> = (verdict, answer) => …;
+ *
+ * const answer = await client.getClass().activate(config, { analyse: t100 });
+ * if (!answer.ok) answer.getError().t100;   // typed, no cast
+ * ```
+ *
+ * The verdict handed in stays `IAdtError`: it is the library's own, built before
+ * any strategy is consulted. Only what comes back is the caller's.
+ */
+export type IAnalyse<E extends IAdtError = IAdtError> = (verdict: IAdtError | AdtNoFailure, answer?: IAdtWireResponse) => E | AdtNoFailure;
+/**
+ * Options for ADT operations (create and update)
+ * Unified interface for both create and update operations
+ */
+export interface IAdtOperationOptions<E extends IAdtError = IAdtError> {
+    /**
+     * {@link IAnalyse} — the caller's own reading of what counts as a failure.
+     *
+     * It exists because no single reading serves every caller. ADT answers a
+     * request for a missing object with 200 and an empty body, and those same
+     * bytes are a failure to a read-modify-write — writing back what it read
+     * erases the object — and an empty list to a listing. Neither reading can be
+     * the library's.
+     *
+     * The status is not the signal: a refusal arrives inside a 200, and what
+     * decides is the message severity in the document, which is why the raw answer
+     * is passed rather than a summary of it.
+     */
+    analyse?: IAnalyse<E>;
+    /**
+     * The source this member writes. **An update's, and only an update's.**
+     *
+     * This used to name an exception — "a DDL source, a table and a program are
+     * created *from* their source, so it is the POST body" — and the exception is
+     * not real. Measured across all 27 create implementations in
+     * `@mcp-abap-adt/adt-clients`: every one of them posts a metadata document
+     * and none carries source. A DDL posts `ddl:ddlSource`, a table posts
+     * `blue:blueSource`, a program posts its program metadata; the text appears
+     * in none of the three bodies.
+     *
+     * The cost of the wrong exception was silence. Five classes created with full
+     * bodies on E19 answered ok at every step, activated, and came back as ADT's
+     * empty skeleton — the only symptom arriving later, when the entry point
+     * refused to run because it did not implement the interface its source
+     * declared. `create` no longer accepts this field, so that call now fails to
+     * compile instead (see {@link IAdtCreateOptions}).
+     *
+     * It used to say "used in create operations for update after create" — that
+     * described a create that wrote the source itself in a second request. A
+     * member is one request now, so where the endpoint does not carry source,
+     * writing it is a separate call the caller makes.
+     */
+    sourceCode?: string;
+    /**
+     * The body of this member’s request, for the objects whose editor content is
+     * XML rather than source — a domain, a data element, a package, an
+     * authorization field.
+     *
+     * Same rule as {@link IAdtOperationOptions.sourceCode}: it is the body of the
+     * one request the member makes, where that endpoint takes one.
+     */
+    xmlContent?: string;
+    /**
+     * The lock handle to put on the write request.
+     *
+     * Nothing more. It used to say the update "will skip lock, check and unlock
+     * operations" when provided, which implied that without one those still
+     * happen — they did, and they no longer do: a member is one request and the
+     * lock is the caller’s, taken with `lock` and released with `unlock`.
+     *
+     * **Leaving it out is not refused here.** Whether a write without a lock is
+     * allowed is ADT’s judgement, and ADT answers it; a library that refused
+     * first would be standing in front of the server with an opinion of its own.
+     */
+    lockHandle?: string;
+    /**
+     * HTTP request timeout for operations in milliseconds
+     * @default 1000 (1 second)
+     *
+     * Note: This timeout is for HTTP request completion, not for waiting object readiness.
+     * For waiting object readiness after create/update/activate operations, use `withLongPolling: true`
+     * in read operations instead of fixed timeouts.
+     *
+     * The `timeout` parameter controls how long to wait for HTTP responses from the server.
+     * Increase timeout for complex operations or slow systems.
+     *
+     * Example: timeout: 5000 for 5 seconds
+     *
+     * @see withLongPolling - Use long polling for waiting object readiness
+     */
+    timeout?: number;
+}
+/**
+ * What `create` accepts: {@link IAdtOperationOptions} without the source.
+ *
+ * A create is the POST that brings the object into existence, and no create
+ * endpoint carries source — checked against all 27 implementations in
+ * `@mcp-abap-adt/adt-clients`, including the three this contract used to name
+ * as exceptions. Writing source is a PUT to `source/main` under a lock, which
+ * `create` neither holds nor can obtain.
+ *
+ * So the field is gone from the member rather than documented as ignored.
+ * Accepting a value that cannot be honoured is worse than refusing it: the call
+ * compiles, runs, answers ok, and leaves an empty object behind, and the
+ * failure surfaces somewhere else entirely.
+ *
+ * **`Omit` alone does not refuse it.** Excess-property checking applies to
+ * object literals and nothing else, so `create(config, opts)` where `opts` is a
+ * variable of type {@link IAdtOperationOptions} carrying `sourceCode` is
+ * structurally assignable and compiles — which is the shape real consumer code
+ * takes. `sourceCode?: never` is what makes the refusal hold for a variable as
+ * well as a literal.
+ */
+export type IAdtCreateOptions<E extends IAdtError = IAdtError> = Omit<IAdtOperationOptions<E>, 'sourceCode'> & {
+    sourceCode?: never;
+};
+//# sourceMappingURL=IAdtObject.d.ts.map

package/dist/adt/IAdtObject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtObject.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtObject.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,eAAO,MAAM,mBAAmB;IAC9B,6BAA6B;;IAE7B,iFAAiF;;IAEjF,+BAA+B;;IAE/B,6BAA6B;;IAE7B,2BAA2B;;IAE3B,6BAA6B;;IAE7B,+BAA+B;;IAE/B,0BAA0B;;IAE1B,4BAA4B;;IAE5B,8BAA8B;;IAE9B,iGAAiG;;CAEzF,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,CACtD,OAAO,EAAE,SAAS,GAAG,YAAY,EACjC,MAAM,CAAC,EAAE,gBAAgB,KACtB,CAAC,GAAG,YAAY,CAAC;AAEtB;;;GAGG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IACnE;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IAmBtB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,IAAI,IAAI,CACnE,oBAAoB,CAAC,CAAC,CAAC,EACvB,YAAY,CACb,GAAG;IAAE,UAAU,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC"}

package/dist/adt/IAdtObject.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Operation options, version entries and error codes shared by the capability
+ * atoms.
+ *
+ * The wide `IAdtObject` this file was named for was removed in 29.0.0; what an
+ * object can do is now stated by the atoms it declares in `IAdtCapabilities.ts`.
+ * Nothing here declares an operation — these are the pieces the atoms refer to:
+ * {@link IAdtOperationOptions} carries the strategy a caller injects,
+ * a version history's entries are the implementation's since 31.0.0, and
+ * {@link AdtObjectErrorCodes} names failures a strategy can put in
+ * {@link IAdtError.code}.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdtObjectErrorCodes = void 0;
+/**
+ * The codes a failure can name itself by.
+ *
+ * **No member of this contract throws** since 30.0.0 — which is about what the
+ * server's answer becomes, not about what an implementation does when its own
+ * reading fails. Every member answers
+ * {@link IAdtResponse}, so a failure comes back rather than flying past, and it
+ * is read from the contract:
+ *
+ * ```typescript
+ * const answer = await adtObject.read({ className: 'ZTEST' });
+ *
+ * if (answer.ok) {
+ *   answer.getResult().value;    // what the endpoint produced
+ * } else {
+ *   const failure = answer.getError();
+ *   failure.origin;              // 'connection' | 'refusal'
+ *   failure.message;             // what SAP said, in SAP's words
+ *   failure.code;                // one of these, when the strategy named one
+ *   failure.response;            // the answer it was read from, untouched
+ * }
+ * ```
+ *
+ * These are for the failures the contract promises in a specific place, where
+ * `origin` alone cannot tell two apart: a version resource a system does not
+ * expose is `UNSUPPORTED_OPERATION` rather than merely a refusal, and a lock
+ * another user holds is `LOCK_FAILED`. A consumer branches on the code without a
+ * cast, which until 30.0.0 they could not — the promise was made by members that
+ * threw, and the failure contract had nowhere to carry it.
+ *
+ * `code` is optional, and deliberately: what a strategy chooses is how much of a
+ * failure to fill in, not whether to be one. An implementation is free to name
+ * codes of its own beside these; this package ships no error class to narrow
+ * with, because a contract says what a thing is and shipping a class from it
+ * would make "use your own implementation" untrue for that piece.
+ *
+ * Note what is *not* among them: "not found". ADT answers a request for a
+ * missing object with **200 and an empty body** rather than a 404, so absence is
+ * not a failure this library can report on its own authority — a read-modify-write
+ * must treat it as one, since writing back what it read erases the object, while
+ * a listing must treat it as an empty list. That reading is supplied through
+ * {@link IAdtOperationOptions.analyse}.
+ */
+exports.AdtObjectErrorCodes = {
+    /** Object not found (404) */
+    OBJECT_NOT_FOUND: 'ADT_OBJECT_NOT_FOUND',
+    /** Object not ready yet (400) - e.g., just created, not available for reading */
+    OBJECT_NOT_READY: 'ADT_OBJECT_NOT_READY',
+    /** Object validation failed */
+    VALIDATION_FAILED: 'ADT_VALIDATION_FAILED',
+    /** Object creation failed */
+    CREATE_FAILED: 'ADT_CREATE_FAILED',
+    /** Object update failed */
+    UPDATE_FAILED: 'ADT_UPDATE_FAILED',
+    /** Object deletion failed */
+    DELETE_FAILED: 'ADT_DELETE_FAILED',
+    /** Object activation failed */
+    ACTIVATE_FAILED: 'ADT_ACTIVATE_FAILED',
+    /** Object check failed */
+    CHECK_FAILED: 'ADT_CHECK_FAILED',
+    /** Lock operation failed */
+    LOCK_FAILED: 'ADT_LOCK_FAILED',
+    /** Unlock operation failed */
+    UNLOCK_FAILED: 'ADT_UNLOCK_FAILED',
+    /** Operation not supported for this object type (e.g. version history on a non-source object) */
+    UNSUPPORTED_OPERATION: 'ADT_UNSUPPORTED_OPERATION',
+};

package/dist/adt/IAdtObjectState.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The configuration shapes an ADT object is identified and created by.
+ *
+ * The state interfaces this file is named for were removed in 29.0.0 — they were
+ * a bag of transport frames, and a state is a shape an *implementation* builds
+ * rather than something a contract hands back. What a member answers is now
+ * named by its own atom in `IAdtCapabilities.ts`.
+ *
+ * The filename outlives them for one release so import paths do not churn twice;
+ * it is `IAdtObjectConfig.ts` in spirit.
+ */
+/**
+ * Base configuration interface for all ADT Object operations
+ *
+ * This interface defines common fields that are present in all ADT object configurations.
+ * Specific configuration types should extend this interface to ensure consistency.
+ *
+ * Example:
+ * ```typescript
+ * export type DomainBuilderConfig = IAdtObjectConfig & {
+ *   domainName: string;
+ *   // ... domain-specific fields
+ *   // packageName, description and transportRequest come from IAdtObjectConfig,
+ *   // composed rather than inherited — decision 23
+ * }
+ * ```
+ */
+export interface IAdtObjectConfig {
+    /** Package name (required for create operations, optional for others) */
+    packageName?: string;
+    /** Description (required for create/validate operations, optional for others) */
+    description?: string;
+    /** Transport request (optional, used for create/update/delete operations) */
+    transportRequest?: string;
+}
+//# sourceMappingURL=IAdtObjectState.d.ts.map

package/dist/adt/IAdtObjectState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtObjectState.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtObjectState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,gBAAgB;IAC/B,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B"}

package/dist/adt/IAdtObjectState.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * The configuration shapes an ADT object is identified and created by.
+ *
+ * The state interfaces this file is named for were removed in 29.0.0 — they were
+ * a bag of transport frames, and a state is a shape an *implementation* builds
+ * rather than something a contract hands back. What a member answers is now
+ * named by its own atom in `IAdtCapabilities.ts`.
+ *
+ * The filename outlives them for one release so import paths do not churn twice;
+ * it is `IAdtObjectConfig.ts` in spirit.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adt/IAdtPackage.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Package ADT operation parameter interfaces (snake_case, low-level)
+ */
+export interface ICreatePackageParams {
+    package_name: string;
+    description?: string;
+    super_package: string;
+    package_type?: string;
+    software_component?: string;
+    transport_layer?: string;
+    transport_request?: string;
+    application_component?: string;
+    responsible?: string;
+    master_system?: string;
+    /** Master/original language (e.g. "EN", "DE"). Defaults to EN when unset. */
+    master_language?: string;
+    record_changes: boolean;
+}
+export interface IUpdatePackageParams {
+    package_name: string;
+    description?: string;
+    super_package?: string;
+    package_type?: string;
+    software_component?: string;
+    transport_layer?: string;
+    transport_request?: string;
+    application_component?: string;
+    responsible?: string;
+    master_system?: string;
+    record_changes?: boolean;
+}
+export interface IDeletePackageParams {
+    package_name: string;
+    transport_request?: string;
+}
+export interface IPackageConfig {
+    /**
+     * The complete document to write, when this config is used for an update.
+     *
+     * **An update is a write, not a read-modify-write.** Until 19.0.0 of
+     * `adt-clients` the five DDIC-shaped updates fetched the current document,
+     * patched the fields named here into it, and PUT the result — two requests in
+     * one member, and a merge whose rules nobody outside could change. They no
+     * longer do: a caller reads the document with the member that reads it, edits
+     * it, and passes it here.
+     *
+     * So the fields beside this one describe a *create*. On an update they are not
+     * sent, and a field left out of `document` is not preserved — there is nothing
+     * to preserve it from, because nothing was read.
+     *
+     * Optional because the same config creates, where there is no document yet.
+     */
+    document?: string;
+    packageName: string;
+    superPackage?: string;
+    description?: string;
+    updatedDescription?: string;
+    packageType?: string;
+    softwareComponent?: string;
+    transportLayer?: string;
+    transportRequest?: string;
+    applicationComponent?: string;
+    responsible?: string;
+    masterSystem?: string;
+    masterLanguage?: string;
+    recordChanges?: boolean;
+    onLock?: (lockHandle: string) => void;
+}
+//# sourceMappingURL=IAdtPackage.d.ts.map

package/dist/adt/IAdtPackage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtPackage.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtPackage.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAKD,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC"}

package/dist/adt/IAdtPackage.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Package ADT operation parameter interfaces (snake_case, low-level)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/adt/IAdtProgram.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Program ADT operation parameter interfaces (snake_case, low-level)
+ */
+export interface ICreateProgramParams {
+    programName: string;
+    description?: string;
+    packageName: string;
+    transportRequest?: string;
+    masterSystem?: string;
+    responsible?: string;
+    masterLanguage?: string;
+    programType?: string;
+    application?: string;
+    activate?: boolean;
+}
+export interface IUpdateProgramSourceParams {
+    programName: string;
+    sourceCode: string;
+    activate?: boolean;
+}
+export interface IDeleteProgramParams {
+    programName: string;
+    transportRequest?: string;
+}
+export interface IProgramConfig {
+    programName: string;
+    masterLanguage?: string;
+    packageName?: string;
+    transportRequest?: string;
+    description?: string;
+    programType?: string;
+    application?: string;
+    sourceCode?: string;
+    sessionId?: string;
+    onLock?: (lockHandle: string) => void;
+}
+//# sourceMappingURL=IAdtProgram.d.ts.map

package/dist/adt/IAdtProgram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtProgram.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtProgram.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAKD,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC"}

package/dist/adt/IAdtProgram.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Program ADT operation parameter interfaces (snake_case, low-level)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });