@mcp-abap-adt/interfaces-adt 1.0.0

package/dist/adt/IAdtResponse.d.ts

@@ -0,0 +1,289 @@
+/**
+ * What a member answers with, once the envelope stops being the answer.
+ *
+ * `IAdtResponse` used to be the transport frame — status, headers, body — handed
+ * to a caller as though it were a result. Decisions 13 to 19 are all consequences
+ * of that one thing, and this is the shape they arrive at: **a response says
+ * whether there is a result and whether there is an error, and both are
+ * contracts.**
+ *
+ * ```typescript
+ * const answer = await utils.search({ query: 'ZCL_*' });
+ *
+ * if (answer.ok) {
+ *   answer.getResult().value;    // whatever this implementation reads
+ * } else {
+ *   answer.getError().origin;    // connection, refusal
+ *   answer.getError().message;   // what SAP said, when SAP said anything
+ * }
+ * ```
+ *
+ * **Why two methods and not one.** A result can be a normal answer or a failure,
+ * and a contract that names only the first pushes the second somewhere the
+ * compiler cannot see — which is the family of defects this line of decisions
+ * came from, restated as a type. Here a caller cannot reach a result without the
+ * contract having told them an error is a thing that exists.
+ *
+ * **Why the error is a contract and not a class.** A consumer swapping in their
+ * own implementation must be able to produce a failure this package describes,
+ * and `instanceof` against a class shipped from here would make "swap in your
+ * own" untrue. The classes that *are* these shapes live in
+ * `@mcp-abap-adt/adt-clients`, where a consumer takes them from if they want
+ * `instanceof` as a convenience.
+ */
+import type { IAdtWireResponse } from '../connection/IAbapConnection';
+/**
+ * What an error strategy answers when the answer is **not** a failure.
+ *
+ * A token, not `undefined`. Until 31.0.0 `analyse` answered
+ * `IAdtError | undefined`, where `undefined` had to mean two different things —
+ * "there is no strategy here" for the optional field, and "this is not a
+ * failure" for its result. A reader could not tell which, and neither could a
+ * type: absence is not a verdict, and a verdict of "fine" is a thing a strategy
+ * says, so it is named.
+ *
+ * ```typescript
+ * analyse: (verdict) => isMissingObject ? ADT_NO_FAILURE : verdict
+ * ```
+ */
+export declare const ADT_NO_FAILURE: "adt:no-failure";
+/** The type of {@link ADT_NO_FAILURE}, for a strategy's signature. */
+export type AdtNoFailure = typeof ADT_NO_FAILURE;
+/**
+ * Where a failure came from — **on the server's side of the wire**.
+ *
+ * A caller cannot act on "something went wrong". Reauthenticating and asking the
+ * server something else are different days of work, and flattening them into one
+ * message makes the caller guess which.
+ *
+ * **Two, not three.** `'parse'` was here until 31.0.0, for an answer that
+ * arrived and could not be read. That is a failure *inside an implementation*,
+ * and this contract describes what came from the server: a strategy is free to
+ * read an answer any way it likes — or not to parse at all — so a category
+ * naming a step it may never take is one it cannot honour. What an
+ * implementation does when its own reading fails is its business, and it may
+ * throw.
+ */
+export type AdtFailureOrigin = 
+/** No usable answer exists — unreachable host, expired session, no authority. */
+'connection'
+/** SAP answered, about this object, and said no. */
+ | 'refusal';
+/**
+ * A failure, whichever strategy produced it.
+ *
+ * Every error strategy returns this — the shipped ones and a consumer's own. What
+ * a strategy chooses is **how much of it to fill in**, not whether to be it: a
+ * `brief` strategy answers `origin` and `message`, a `full` one adds the response,
+ * the request and the server's own classification. A caller writes against this
+ * once and reads whatever their strategy chose to provide.
+ *
+ * Two fields are required because they are the least a failure can say and still
+ * be actionable: what kind of failure it was, and what was said about it.
+ *
+ * **The point is that the methods do not change.** An implementation may fill
+ * this in however it likes — parse the document differently, classify `origin`
+ * by its own rules, decide what "brief" means for the systems it talks to — and
+ * a consumer's code is untouched, because what they call and what they read is
+ * the same either way. That is the difference between a contract and a shape
+ * agreed by luck.
+ *
+ * Everything here is what the library was given rather than what it concluded.
+ * The one judgement in it is `origin`, and that judgement is the strategy's —
+ * replace the strategy and it goes with it.
+ */
+export interface IAdtError {
+    /** Which of the two this is. */
+    readonly origin: AdtFailureOrigin;
+    /**
+     * What SAP said, verbatim where SAP said anything.
+     *
+     * Not a summary and not a translation. A refusal that names the user holding a
+     * lock is only useful if that name survives. The document it was read out of
+     * is `response.data`.
+     */
+    readonly message: string;
+    /**
+     * `<type id="…">` — the server's own classification, when it gave one.
+     *
+     * Derived from the document and kept anyway: it is the one part every consumer
+     * would otherwise parse out for themselves, and it is the server's word rather
+     * than ours. The document itself is not repeated — it is `response.data`, and
+     * two fields for one thing is the fault this design has been removing.
+     */
+    readonly adtType?: string;
+    /** `<namespace id="…">`, when the document names one. */
+    readonly namespace?: string;
+    /** The response it arrived on, when an answer arrived at all. */
+    readonly response?: IAdtWireResponse;
+    /**
+     * The call that produced it.
+     *
+     * A chain issues several: `delete()` sends two, `create()` six. "Object is
+     * locked" means a different thing depending on which asked, and a caller
+     * cannot analyse what they cannot locate.
+     */
+    readonly request?: {
+        readonly method?: string;
+        readonly url?: string;
+    };
+    /**
+     * The failure's own code, when the strategy names one.
+     *
+     * {@link AdtObjectErrorCodes} holds the constants. It is here because the
+     * contract promises specific failures in specific places — a version resource
+     * a system does not expose is `UNSUPPORTED_OPERATION`, and a lock another user
+     * holds is `LOCK_FAILED` — and until 30.0.0 those promises were made by
+     * members that threw, so a consumer read the code off whatever was caught.
+     * With nothing throwing, a promise the failure contract cannot carry is a
+     * promise no consumer can keep without a cast.
+     *
+     * Optional, like `adtType` and `namespace` beside it: what a strategy chooses
+     * is how much of this to fill in, not whether to be it. A `brief` strategy may
+     * answer `origin` and `message` alone.
+     *
+     * ```typescript
+     * const answer = await versionable.getVersions({ className: 'ZCL_X' });
+     * if (!answer.ok && answer.getError().code === AdtObjectErrorCodes.UNSUPPORTED_OPERATION) {
+     *   // this type has no version resource — ask something else
+     * }
+     * ```
+     */
+    readonly code?: string;
+}
+/**
+ * The answer to a call: a result **or** a failure, never both and never neither.
+ *
+ * A union rather than one shape with two optional halves, and that is not a
+ * detail. Two independently-optional methods let an implementation answer both
+ * or answer nothing, and — worse — checking one does not narrow the other, so
+ * the claim "a caller cannot reach a result without being told an error exists"
+ * was a sentence in a comment rather than a thing the compiler did.
+ *
+ * ```typescript
+ * const answer = await utils.search({ query: 'ZCL_*' });
+ *
+ * if (answer.ok) {
+ *   answer.getResult().value;    // the value — not `| undefined`
+ * } else {
+ *   answer.getError().origin;    // IAdtError — not `| undefined`
+ * }
+ * ```
+ *
+ * `ok` exists because TypeScript cannot narrow an object from what a method
+ * returns. It is the smallest thing that makes the guarantee real: one field,
+ * and both methods stop being maybes.
+ *
+ * **A strategy chooses how much, never what it is.** `brief`, `medium` and
+ * `full` are three amounts of one contract, so a caller writes against
+ * `IAdtError` once and reads whatever their strategy provided.
+ *
+ * **The type parameter has no default.** A member answering `IAdtResponse` and
+ * promising nothing is the free type this design refuses, reached by omission.
+ */
+export interface IAdtSuccess<TValue> {
+    readonly ok: true;
+    getResult(): IAdtResult<TValue>;
+}
+/** The other half of {@link IAdtResponse}: a failure, and no result. */
+export interface IAdtFailure<TError extends IAdtError = IAdtError> {
+    readonly ok: false;
+    getError(): TError;
+}
+/**
+ * A result, as the contract it is — the other half of the pair with
+ * {@link IAdtError}.
+ *
+ * **The two halves are not symmetric in how they vary, and saying otherwise was
+ * wrong.** An error strategy varies the *fullness of one contract*: `IAdtError`
+ * has two required fields and five optional ones, so `brief` and `full` are
+ * genuinely two amounts of it. A result cannot work that way: a hit shape with
+ * a required `description` cannot be returned with fewer fields without the
+ * compiler refusing.
+ *
+ * A result strategy varies **`T` itself**, and `T` follows the strategy the
+ * implementation was constructed with (decision 22):
+ * `IAdtInformationSystem<MyHits, …>` answers `IAdtResponse<MyHits>` from the
+ * same `search(criteria)` call, and another implementation answers its own. A shipped `brief` is a shipped reading with a
+ * narrower result contract, not the same contract half-filled.
+ *
+ * Until 30.0.0 this said "the strategy overload", and four members took a parser
+ * at the call. They do not any more — a per-call parser is a second signature
+ * every implementer owes whether or not their callers use it.
+ *
+ * So what does this interface buy, if it holds one field? It is the **named half
+ * of an answer**, the counterpart to `IAdtError`, and it is where anything a
+ * result needs to say *about itself* goes when a case for one appears — stated
+ * as a contract, which is decision 19's rule for what a result may carry. What it must never hold is the
+ * transport frame: a `response` field was in the first draft and put `status`,
+ * `headers` and `data` back inside every result under one more layer of nesting.
+ *
+ * A caller who wants the document asks for it the way decision 19 says: a result
+ * strategy of their own that answers the document, in a member whose contract
+ * says that is what it gives.
+ *
+ * A bare `T` was tried here and is wrong for the reason a bare `TError` was
+ * wrong: a member that hands back an unwrapped value has no room to say anything
+ * about it, so "how much" becomes a question only the error side can ask. Both
+ * sides of an answer are contracts, or neither is.
+ */
+export interface IAdtResult<T> {
+    /** What the member promised — whatever this implementation reads. */
+    readonly value: T;
+}
+/**
+ * How an answer becomes a value.
+ *
+ * {@link IAdtResult} says a result has a value; this says where that value came
+ * from. One endpoint serves callers who want very different amounts of it — an
+ * MCP server passing the answer to a language model, where size is a budget; a
+ * backup tool that must keep the document byte for byte; a script that wants two
+ * fields — and none of those readings is more correct than the others.
+ *
+ * So the reading is not the library's. It is injected into the implementation
+ * once, and the member's result type follows it (decision 22). What is *not*
+ * offered is a second member per reading — that is decision 16 — nor a parse
+ * argument at the call, which was tried across 23 members and reverted.
+ *
+ * **It is handed the whole answer, not the body.** A reading may need the status
+ * or a header, and {@link IAdtOperationOptions.analyse}, the strategy on the
+ * error axis, already takes the answer for the same reason. The two axes are
+ * symmetric: one decides whether an answer is a failure at all, the other what a
+ * non-failure becomes.
+ *
+ * **It sees this member's own answer.** Requests an implementation issues on the
+ * way — to obtain a node id, a scope document, a token — are its own business and
+ * reach the consumer only as failures.
+ *
+ * ```typescript
+ * const raw: IResultStrategy<string> = (answer) => String(answer.data);
+ * ```
+ */
+export type IResultStrategy<T> = (answer: IAdtWireResponse) => T;
+/**
+ * What a member answers with.
+ *
+ * The direction for all of them, and reached member by member — decision 19 says
+ * nothing forces them to move together. As of 28.0.0 the 22 asynchronous members
+ * of `IAdtUtilities` have; 169 elsewhere have not, and still answer their result
+ * or a frame directly. Each converges when it is next touched.
+ *
+ * **Both halves are parameters, and both are constrained to their contract.**
+ * That is the difference between a type parameter and a free one: an
+ * implementation may hand back `IAdtError & { retryAfter: number }` and say so in
+ * the type, and a caller written against `IAdtError` still reads it. Fixing the
+ * error half at `IAdtError` — which the first version did — left an
+ * implementation with no way to describe what it actually returns, which is the
+ * opposite of "swap in your own".
+ *
+ * `TValue` is what the member promised, typed all the way through: a caller
+ * reads `getResult().value` and gets that value typed, never a cast. `IAdtResult`
+ * is the contract carrying it, and it is not written at the call site — a member
+ * that adds nothing writes `IAdtResponse<TValue>` and no more.
+ *
+ * `TError` defaults to `IAdtError` and is constrained to it, which is what keeps
+ * two implementations of one member interchangeable: a caller may read more than
+ * the contract if their implementation offers more, and never less.
+ */
+export type IAdtResponse<TValue, TError extends IAdtError = IAdtError> = IAdtSuccess<TValue> | IAdtFailure<TError>;
+//# sourceMappingURL=IAdtResponse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtResponse.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtResponse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,EAAG,gBAAyB,CAAC;AAExD,sEAAsE;AACtE,MAAM,MAAM,YAAY,GAAG,OAAO,cAAc,CAAC;AAEjD;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,gBAAgB;AAC1B,iFAAiF;AAC/E,YAAY;AACd,oDAAoD;GAClD,SAAS,CAAC;AAEd;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,SAAS;IACxB,gCAAgC;IAChC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAElC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B,yDAAyD;IACzD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAE5B,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAErC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE;QACjB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IAEF;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,WAAW,WAAW,CAAC,MAAM;IACjC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,SAAS,IAAI,UAAU,CAAC,MAAM,CAAC,CAAC;CACjC;AAaD,wEAAwE;AACxE,MAAM,WAAW,WAAW,CAAC,MAAM,SAAS,SAAS,GAAG,SAAS;IAC/D,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,IAAI,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,gBAAgB,KAAK,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,MAAM,YAAY,CAAC,MAAM,EAAE,MAAM,SAAS,SAAS,GAAG,SAAS,IACjE,WAAW,CAAC,MAAM,CAAC,GACnB,WAAW,CAAC,MAAM,CAAC,CAAC"}

package/dist/adt/IAdtResponse.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * What a member answers with, once the envelope stops being the answer.
+ *
+ * `IAdtResponse` used to be the transport frame — status, headers, body — handed
+ * to a caller as though it were a result. Decisions 13 to 19 are all consequences
+ * of that one thing, and this is the shape they arrive at: **a response says
+ * whether there is a result and whether there is an error, and both are
+ * contracts.**
+ *
+ * ```typescript
+ * const answer = await utils.search({ query: 'ZCL_*' });
+ *
+ * if (answer.ok) {
+ *   answer.getResult().value;    // whatever this implementation reads
+ * } else {
+ *   answer.getError().origin;    // connection, refusal
+ *   answer.getError().message;   // what SAP said, when SAP said anything
+ * }
+ * ```
+ *
+ * **Why two methods and not one.** A result can be a normal answer or a failure,
+ * and a contract that names only the first pushes the second somewhere the
+ * compiler cannot see — which is the family of defects this line of decisions
+ * came from, restated as a type. Here a caller cannot reach a result without the
+ * contract having told them an error is a thing that exists.
+ *
+ * **Why the error is a contract and not a class.** A consumer swapping in their
+ * own implementation must be able to produce a failure this package describes,
+ * and `instanceof` against a class shipped from here would make "swap in your
+ * own" untrue. The classes that *are* these shapes live in
+ * `@mcp-abap-adt/adt-clients`, where a consumer takes them from if they want
+ * `instanceof` as a convenience.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADT_NO_FAILURE = void 0;
+/**
+ * What an error strategy answers when the answer is **not** a failure.
+ *
+ * A token, not `undefined`. Until 31.0.0 `analyse` answered
+ * `IAdtError | undefined`, where `undefined` had to mean two different things —
+ * "there is no strategy here" for the optional field, and "this is not a
+ * failure" for its result. A reader could not tell which, and neither could a
+ * type: absence is not a verdict, and a verdict of "fine" is a thing a strategy
+ * says, so it is named.
+ *
+ * ```typescript
+ * analyse: (verdict) => isMissingObject ? ADT_NO_FAILURE : verdict
+ * ```
+ */
+exports.ADT_NO_FAILURE = 'adt:no-failure';

package/dist/adt/IAdtScalarFunction.d.ts

@@ -0,0 +1,30 @@
+/**
+ * ScalarFunction (CDS DSFD/SCF) ADT operation parameter interfaces (low-level)
+ */
+export interface ICreateScalarFunctionParams {
+    scalar_function_name: string;
+    description?: string;
+    package_name: string;
+    transport_request?: string;
+    masterSystem?: string;
+    responsible?: string;
+    masterLanguage?: string;
+}
+export interface IUpdateScalarFunctionParams {
+    scalar_function_name: string;
+    source_code: string;
+    transport_request?: string;
+}
+export interface IDeleteScalarFunctionParams {
+    scalar_function_name: string;
+    transport_request?: string;
+}
+export interface IScalarFunctionConfig {
+    scalarFunctionName: string;
+    masterLanguage?: string;
+    packageName?: string;
+    transportRequest?: string;
+    description?: string;
+    sourceCode?: string;
+}
+//# sourceMappingURL=IAdtScalarFunction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtScalarFunction.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtScalarFunction.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,2BAA2B;IAC1C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,2BAA2B;IAC1C,oBAAoB,EAAE,MAAM,CAAC;IAC7B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAGD,MAAM,WAAW,qBAAqB;IACpC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,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;CACrB"}

package/dist/adt/IAdtScalarFunction.js

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

package/dist/adt/IAdtScalarFunctionImplementation.d.ts

@@ -0,0 +1,35 @@
+/**
+ * ScalarFunctionImplementation (DSFI/SFI) ADT operation parameter interfaces (low-level)
+ */
+export type ScalarFunctionEngine = 'sqlEngine' | 'amdpEngine';
+export interface ICreateScalarFunctionImplementationParams {
+    implementation_name: string;
+    scalar_function_name: string;
+    engine_value?: ScalarFunctionEngine;
+    description?: string;
+    package_name: string;
+    transport_request?: string;
+    masterSystem?: string;
+    responsible?: string;
+    masterLanguage?: string;
+}
+export interface IUpdateScalarFunctionImplementationParams {
+    implementation_name: string;
+    source_code: string;
+    transport_request?: string;
+}
+export interface IDeleteScalarFunctionImplementationParams {
+    implementation_name: string;
+    transport_request?: string;
+}
+export interface IScalarFunctionImplementationConfig {
+    implementationName: string;
+    scalarFunctionName: string;
+    engineValue?: ScalarFunctionEngine;
+    masterLanguage?: string;
+    packageName?: string;
+    transportRequest?: string;
+    description?: string;
+    sourceCode?: string;
+}
+//# sourceMappingURL=IAdtScalarFunctionImplementation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtScalarFunctionImplementation.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtScalarFunctionImplementation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,oBAAoB,GAAG,WAAW,GAAG,YAAY,CAAC;AAE9D,MAAM,WAAW,yCAAyC;IACxD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yCAAyC;IACxD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,yCAAyC;IACxD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,mCAAmC;IAClD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,CAAC,EAAE,oBAAoB,CAAC;IACnC,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;CACrB"}

package/dist/adt/IAdtScalarFunctionImplementation.js

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

package/dist/adt/IAdtServiceBinding.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Service Binding ADT operation parameter interfaces (snake_case, low-level)
+ */
+export type ServiceBindingType = 'ODATA' | 'INA' | 'SQL';
+export type ServiceBindingVersion = 'V2' | 'V4' | '0001' | '0000' | string;
+export type GeneratedServiceType = 'odatav2' | 'odatav4';
+export type DesiredPublicationState = 'published' | 'unpublished' | 'unchanged';
+export type ServiceBindingVariant = 'ODATA_V2_UI' | 'ODATA_V2_WEB_API' | 'ODATA_V4_UI' | 'ODATA_V4_WEB_API';
+export declare const SERVICE_BINDING_VARIANT_MAP: Record<ServiceBindingVariant, {
+    bindingType: ServiceBindingType;
+    bindingVersion: ServiceBindingVersion;
+    bindingCategory: '0' | '1';
+    serviceType: GeneratedServiceType;
+}>;
+export interface ICreateServiceBindingParams {
+    bindingName: string;
+    packageName: string;
+    description: string;
+    serviceDefinitionName: string;
+    serviceName: string;
+    serviceVersion: string;
+    bindingVariant: ServiceBindingVariant;
+    masterLanguage?: string;
+    masterSystem?: string;
+    responsible?: string;
+    transportRequest?: string;
+    runTransportCheck?: boolean;
+    activateAfterCreate?: boolean;
+}
+export interface IReadServiceBindingParams {
+    bindingName: string;
+    version?: 'active' | 'inactive';
+}
+export interface IUpdateServiceBindingParams {
+    bindingName: string;
+    desiredPublicationState: DesiredPublicationState;
+    serviceType: GeneratedServiceType;
+    serviceName: string;
+    serviceVersion?: string;
+}
+export interface IDeleteServiceBindingParams {
+    bindingName: string;
+    transportRequest?: string;
+}
+export interface IServiceBindingConfig {
+    bindingName: string;
+    packageName?: string;
+    description?: string;
+    serviceDefinitionName?: string;
+    serviceName?: string;
+    serviceVersion?: string;
+    bindingVariant?: ServiceBindingVariant;
+    masterLanguage?: string;
+    masterSystem?: string;
+    responsible?: string;
+    desiredPublicationState?: DesiredPublicationState;
+    serviceType?: GeneratedServiceType;
+    transportRequest?: string;
+    runTransportCheck?: boolean;
+}
+//# sourceMappingURL=IAdtServiceBinding.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtServiceBinding.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtServiceBinding.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,KAAK,GAAG,KAAK,CAAC;AACzD,MAAM,MAAM,qBAAqB,GAAG,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAC3E,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,SAAS,CAAC;AACzD,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG,aAAa,GAAG,WAAW,CAAC;AAEhF,MAAM,MAAM,qBAAqB,GAC7B,aAAa,GACb,kBAAkB,GAClB,aAAa,GACb,kBAAkB,CAAC;AAGvB,eAAO,MAAM,2BAA2B,EAAE,MAAM,CAC9C,qBAAqB,EACrB;IACE,WAAW,EAAE,kBAAkB,CAAC;IAChC,cAAc,EAAE,qBAAqB,CAAC;IACtC,eAAe,EAAE,GAAG,GAAG,GAAG,CAAC;IAC3B,WAAW,EAAE,oBAAoB,CAAC;CACnC,CA0BF,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,qBAAqB,CAAC;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;CACjC;AAED,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,WAAW,EAAE,oBAAoB,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uBAAuB,CAAC,EAAE,uBAAuB,CAAC;IAClD,WAAW,CAAC,EAAE,oBAAoB,CAAC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B"}

package/dist/adt/IAdtServiceBinding.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Service Binding ADT operation parameter interfaces (snake_case, low-level)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVICE_BINDING_VARIANT_MAP = void 0;
+// Future: INA_UI, SQL_WEB_API — see fr0ster/mcp-abap-adt-clients#18
+exports.SERVICE_BINDING_VARIANT_MAP = {
+    ODATA_V2_UI: {
+        bindingType: 'ODATA',
+        bindingVersion: 'V2',
+        bindingCategory: '0',
+        serviceType: 'odatav2',
+    },
+    ODATA_V2_WEB_API: {
+        bindingType: 'ODATA',
+        bindingVersion: 'V2',
+        bindingCategory: '1',
+        serviceType: 'odatav2',
+    },
+    ODATA_V4_UI: {
+        bindingType: 'ODATA',
+        bindingVersion: 'V4',
+        bindingCategory: '0',
+        serviceType: 'odatav4',
+    },
+    ODATA_V4_WEB_API: {
+        bindingType: 'ODATA',
+        bindingVersion: 'V4',
+        bindingCategory: '1',
+        serviceType: 'odatav4',
+    },
+};

package/dist/adt/IAdtServiceDefinition.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Service Definition ADT operation parameter interfaces (snake_case, low-level)
+ */
+export interface ICreateServiceDefinitionParams {
+    service_definition_name: string;
+    description?: string;
+    package_name: string;
+    transport_request?: string;
+    masterSystem?: string;
+    responsible?: string;
+    masterLanguage?: string;
+}
+export interface IUpdateServiceDefinitionParams {
+    service_definition_name: string;
+    source_code: string;
+    transport_request?: string;
+}
+export interface IDeleteServiceDefinitionParams {
+    service_definition_name: string;
+    transport_request?: string;
+}
+export interface IServiceDefinitionConfig {
+    serviceDefinitionName: string;
+    masterLanguage?: string;
+    packageName?: string;
+    transportRequest?: string;
+    description?: string;
+    sourceCode?: string;
+}
+//# sourceMappingURL=IAdtServiceDefinition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IAdtServiceDefinition.d.ts","sourceRoot":"","sources":["../../src/adt/IAdtServiceDefinition.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,8BAA8B;IAC7C,uBAAuB,EAAE,MAAM,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,8BAA8B;IAC7C,uBAAuB,EAAE,MAAM,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,8BAA8B;IAC7C,uBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAGD,MAAM,WAAW,wBAAwB;IACvC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,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;CACrB"}

package/dist/adt/IAdtServiceDefinition.js

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