@mcp-abap-adt/interfaces-adt 21.0.0 → 23.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (16) hide show
  1. package/CHANGELOG.md +124 -0
  2. package/README.md +87 -3
  3. package/dist/adt/AdtTypeTables.d.ts +133 -23
  4. package/dist/adt/AdtTypeTables.d.ts.map +1 -1
  5. package/dist/adt/AdtTypeTables.js +30 -31
  6. package/dist/adt/AdtUtilityCodes.d.ts +146 -0
  7. package/dist/adt/AdtUtilityCodes.d.ts.map +1 -0
  8. package/dist/adt/AdtUtilityCodes.js +73 -0
  9. package/dist/adt/IAdtShared.d.ts +60 -6
  10. package/dist/adt/IAdtShared.d.ts.map +1 -1
  11. package/dist/adt/IAdtUtilities.d.ts +96 -2
  12. package/dist/adt/IAdtUtilities.d.ts.map +1 -1
  13. package/dist/index.d.ts +5 -3
  14. package/dist/index.d.ts.map +1 -1
  15. package/dist/index.js +5 -1
  16. package/package.json +1 -1
package/CHANGELOG.md CHANGED
@@ -7,6 +7,130 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
7
7
 
8
8
  ## [Unreleased]
9
9
 
10
+ ## [23.0.0] - 2026-10-28
11
+
12
+ ### Changed (breaking)
13
+
14
+ - **`ADT_TYPES_CLOUD`: a program and an include list what a delivered one
15
+ answers, as measured.** ABAP cloud has no program or include of one's own:
16
+ its discovery gives neither collection an `app:accept`, and the create is
17
+ refused (`403`, S_DEVELOP). Measured on the BTP trial 2026-10-28 on a
18
+ delivered program and include:
19
+ - answered: `read`, `source`, `readMetadata`, `check` and `versions` (the
20
+ program's), `deletionCheck` (its `del:checkResponse`, not deletable), the
21
+ enhancement elements and options, and for a program the ABAP Unit run, its
22
+ status and result, and the synchronous run;
23
+ - refused: `transport` (`404`), `run` and `profile` (`200` with "You are not
24
+ authorized to execute this object" as the body).
25
+
26
+ So `PROG/P` lists `read`, `source`, `readMetadata`, `check`, `versions`,
27
+ `deletionCheck`, `readEnhancementElements`, `readEnhancementOptions`,
28
+ `unitTestRun`, `unitTestRunSync`, `unitTestStatus` and `unitTestResult`,
29
+ and `PROG/I` `read`, `source`, `readMetadata`, `deletionCheck` and the two
30
+ enhancement reads. Against 22.0.0 that removes `transport`, `run` and
31
+ `profile` from `PROG/P` — a narrowing, so a major — and adds
32
+ `deletionCheck` to both, which 22.0.0 had dropped by inference. A change of
33
+ an object (`create`, `update`, `updateMetadata`, `lock`, `unlock`,
34
+ `activate`, `delete`) and `validate`, which only prepares a create, stay
35
+ out. `AdtCodeWith<AdtModernVariant, Op>` follows.
36
+ - **`ADT_TYPES_CLOUD`: a feature toggle (`FTG2/FT`) is only read.** A table
37
+ lists a read where its release's discovery has the endpoint, and an
38
+ operation that changes an object (`create`, `update`, `updateMetadata`,
39
+ `lock`, `unlock`, `activate`, `delete`, a feature toggle's `switchOn` and
40
+ `switchOff`, and the `validate` that prepares a create) where the release
41
+ offers it — its discovery, and a measurement — and not where a measurement
42
+ on the release refused it. On ABAP cloud the create answers `403` (measured
43
+ on the BTP trial 2026-10-28; its `typestructure` gives the measuring user no
44
+ `CREATE` for the type): `FTG2/FT` keeps `read`, `source`, `readMetadata`,
45
+ `check`, `deletionCheck`, `getRuntimeState` and `checkState`. On S/4HANA
46
+ 2025 it keeps every operation; a system may still refuse one — an S/4HANA
47
+ 2025 system answers `403` "It is not allowed to create/update feature
48
+ toggles in this system" (`FTG2/035`), a setting of that system, which
49
+ reaches the caller as the system's answer.
50
+
51
+ ## [22.0.0] - 2026-10-28
52
+
53
+ A major for one change: the ABAP cloud table loses the program and include
54
+ operations the cloud refuses (see "Changed (breaking)"). Everything else is
55
+ added beside 21.0.0's types: each keeps its meaning, and a type parameter
56
+ added to an existing type has the 21.0.0 type as its default.
57
+
58
+ ### Changed (breaking)
59
+
60
+ - **`ADT_TYPES_CLOUD`: a program and an include change nothing.** ABAP cloud
61
+ refuses to create either (`403`, S_DEVELOP, measured on the BTP trial
62
+ 2026-10-28), so `PROG/P` and `PROG/I` no longer list `create`, `update`,
63
+ `lock`, `unlock`, `activate`, `validate`, `deletionCheck` or `delete`.
64
+ What a delivered one answers stays: `read`, `source` and `readMetadata`
65
+ (measured on both), `check` and `versions` for a program (measured),
66
+ and the operations not measured — the enhancement reads, `transport`,
67
+ `run`, `profile` and the unit-test runs — as the release's `typestructure`
68
+ lists them. Leaving out the change operations beyond `create` is an
69
+ inference from the refusal: S_DEVELOP is the change authorization, and an
70
+ object nobody can create has nothing of one's own to change. A function
71
+ include (`FUGR/I`) is unchanged: the cloud creates one (`200`, measured).
72
+ `AdtTypeCodeWith<'cloud', Op>` and `AdtCodeWith<AdtModernVariant, Op>` no
73
+ longer name `PROG/P` or `PROG/I` for those operations, and the cloud table
74
+ is no longer the on-premise one in operations.
75
+
76
+ ### Added
77
+
78
+ - **`updateMetadata`** on `CLAS/OC`, `INTF/OI`, `FUGR/FF` and `DDLS/DF` in
79
+ `ADT_TYPES_ONPREM` and `ADT_TYPES_CLOUD`, and on `PROG/P` in
80
+ `ADT_TYPES_ONPREM`: the object's whole metadata document, written back with
81
+ the media type it was read with, answers `200` on S/4HANA 2025 and on ABAP
82
+ cloud (measured 2026-10-27). 7.40 is not measured yet and keeps none.
83
+
84
+ - **Intersecting helpers.** `AdtCodeOf<V>` and `AdtCodeWith<V, Op>`: the codes
85
+ every variant of `V` lists (with `Op`) — the default modern variant,
86
+ `AdtModernVariant` (`'onprem' | 'cloud'`), gets what both newer tables
87
+ serve. `AdtCodeOfIn<Tables, V>` and `AdtCodeWithIn<Tables, V, Op>` are the
88
+ same over any set of tables; `AdtServingVariantsIn<Tables, A>` and
89
+ `AdtPerformingVariantsIn<Tables, A, Op>` name the variants whose table
90
+ serves an API, or one of its codes an operation. `AdtTypeCodeOf`,
91
+ `AdtTypeCodeWith`, `AdtApiWith` and `AdtApiWithIn` are unchanged; their docs
92
+ now state what they answer for a union of variants — the APIs all of them
93
+ serve, and for those the codes and operations any of them lists.
94
+ - **Utility code tables**, `ADT_UTILITY_CODES_ONPREM`, `_CLOUD`,
95
+ `_BASIS_740` (`IAdtUtilityCodeTables`, `AdtUtilityCodeTable<R>`,
96
+ `IAdtUtilityCodeFacts<R>`, `AdtUtilityOperation`, `AdtUtilityCodeWith<V,
97
+ Op>`, `AdtUtilityCode`): the codes `getUtils()` takes beyond the API tables,
98
+ each with its operations, whether they were measured, and its evidence.
99
+ - `VIEW/DV`, a DDIC database view, on every release: group activation,
100
+ group deletion and where-used, under `/sap/bc/adt/ddic/views`. No API
101
+ serves it — a **group-only code**, `AdtGroupOnlyCode`,
102
+ `AdtGroupOnlyCodeOf<V>`. Sent, unmeasured.
103
+ - `DEVC/K` in a group activation on the newer releases — sent, unmeasured.
104
+ - `DEVC/K` in `fetchNodeStructure` on 7.40 — measured (the legacy
105
+ `UtilsReaders` cycle). A table of its own rather than a package entry on
106
+ 7.40, because an entry would gate `getPackage()` open where every package
107
+ member is refused, and a new `AdtOperation` word would break a 21.0.0
108
+ consumer's exhaustive map over the vocabulary.
109
+ - `IObjectReference<C>`, `IGetWhereUsedParams<C>` and
110
+ `IGetWhereUsedScopeParams<C>` take a group-only code as their type
111
+ argument (`IObjectReference<'VIEW/DV'>`). Their defaults are 21.0.0's: a
112
+ bare `IObjectReference` still admits `AdtTypeCode` alone.
113
+ - **What each group operation is given:** `AdtGroupActivationCode<V>`,
114
+ `AdtGroupDeletionCheckCode<V>`, `AdtGroupDeletionCode<V>` (no `MSAG/NN`,
115
+ which has no address of its own), `AdtWhereUsedCode<V>` (no `FUGR/I` or
116
+ `MSAG/NN`), and the references over them, `IAdtGroupActivationReference<V>`,
117
+ `IAdtGroupDeletionCheckReference<V>`, `IAdtGroupDeletionReference<V>`,
118
+ `IAdtWhereUsedParamsOf<V>`, `IAdtWhereUsedScopeParamsOf<V>`, built by
119
+ `IAdtCodedReference<C>`: `parentName` required for each parented code, and
120
+ a reference from a code known only by its set compiles when it names its
121
+ parent — inside TypeScript's 25-combination limit.
122
+ - `IAdtTypedGroupLifecycle<TActivation, TDeletionCheck, TDeletion, V>` and
123
+ `IAdtTypedWhereUsed<TWhereUsed, TScope, V>`: the group and where-used members
124
+ over those references. New atoms beside `IAdtGroupLifecycle` and
125
+ `IAdtWhereUsed`, with the same member names: an implementation declaring
126
+ both offers both signatures, and a caller passing `IObjectReference[]` is
127
+ unaffected. Adding the signatures to the 21.0.0 atoms instead would have
128
+ made every implementation of them stop compiling.
129
+ - `IAdtTypeStructure<TTypeStructure>`: `getTypeStructure({ headers })`,
130
+ `POST /sap/bc/adt/repository/typestructure`, an atom of its own like
131
+ `IAdtObjectProperties`, and `IUtilResults.typeStructure`, its reading —
132
+ optional, so a 21.0.0 result set is still one.
133
+
10
134
  ## [21.0.0] - 2026-10-27
11
135
 
12
136
  ### Added
package/README.md CHANGED
@@ -11,6 +11,7 @@ ADT contracts: object operations, runtime analysis, execution, feeds and service
11
11
  - Since 14.0.0 `IDebuggerIdentity` is a union by `debuggingMode` (required), `attach` takes the identity, `condition` is for line breakpoints only, and `IAbapDebugger` gains `TSettings` and five members. The CHANGELOG has the migration note.
12
12
  - Since 15.0.0 `skipCount` is gone from breakpoints (the server ignores it) and `clientId` pairs an answer row with its request. The CHANGELOG has the migration note.
13
13
  - Since 15.1.0 the plain class and program run take `debuggee` (`IDebuggeeIds`): the terminal id and IDE id a terminal-mode listener catches the run by.
14
+ - Since 23.0.0, a program and an include on ABAP cloud list only what a delivered one answers (no create, change, transport, run or profile), and a feature toggle is only read there (see "Migrating to 23.0.0"); since 22.0.0, and `updateMetadata` is listed where it was measured. Beside that, additions only: intersecting helpers (`AdtCodeOf<V>`, `AdtCodeWith<V, Op>`, `AdtServingVariantsIn`, `AdtPerformingVariantsIn`; the default `AdtModernVariant` gets what both newer tables serve), utility code tables per variant (`ADT_UTILITY_CODES_*`: the group-only `VIEW/DV`, `DEVC/K` in a modern group activation and in 7.40's node structure), group references per operation with the typed atoms `IAdtTypedGroupLifecycle` and `IAdtTypedWhereUsed`, and `IAdtTypeStructure` with its `IUtilResults.typeStructure` slot. See "Intersections, group-only codes and group references".
14
15
  - Since 21.0.0 the object type codes are the library's own tables — `ADT_TYPES_ONPREM` (S/4HANA 2025), `ADT_TYPES_CLOUD` (ABAP cloud), `ADT_TYPES_BASIS_740` (SAP_BASIS 7.40 SP04), keyed by API — and every code in a contract is an `AdtTypeCode` drawn from them. `AdtObjectTypeLower`, `AdtObjectType`, `AdtSourceObjectTypeLower` and `AdtSourceObjectType` are removed, and with them the codes no release lists. An identifying atom takes the parent's field as its last type parameter (`TParent`, default `never`, which leaves the config `Partial<TConfig>` as before), and `IObjectReference<C>` requires `parentName` for a code with a parent. A code read from an answer is an `IAdtAnsweredObject`. See "The ADT type tables" and "Migrating to 21.0.0".
15
16
  - Since 20.2.0 every object's result-set contract (`IClassResults`, `IProgramResults`, … 30 in all, `IMessageClassMessageResults<TRead, TWritten, TDeleted>` among them) and `IServiceBindingPublicationConfig` are declared here, in the object's own `IAdtX.ts`: the slot map an implementation is constructed with, each slot an `IResultStrategy<unknown>`. A consumer composes its client contract from these and the atoms. Additions only.
16
17
  - Since 20.1.0 `IAdtObjectProperties` reads one repository object's properties from `/informationsystem/objectproperties/values?uri=`, any object uri (a transaction by its `vit` workbench uri); its own atom, not part of `IAdtInformationSystem`.
@@ -31,14 +32,14 @@ npm install @mcp-abap-adt/interfaces-adt
31
32
 
32
33
  | directory | files | what |
33
34
  |---|---|---|
34
- | `adt/` | 41 | the object contracts: capability atoms, the object types, the ADT type tables and their entry shape, `IAdtResponse`, `IAdtError`, the error codes, the transport request's object list |
35
+ | `adt/` | 42 | the object contracts: capability atoms, the object types, the ADT type tables and their entry shape, `IAdtResponse`, `IAdtError`, the error codes, the transport request's object list |
35
36
  | `runtime/` | 14 | runtime analysis: the debuggers (`IAbapDebugger`, `IAmdpDebugger`) and `IMemorySnapshots`, `IProfiler`, the trace contracts (`ITraceListing`/`ITraceReading`, `ICrossTrace`, `ISt05Trace`), `IApplicationLog`, `IAtcLog` and the ATC run (`IAtcRunOptions`, `IAtcFindings`), `IDdicActivation`, `IGatewayErrorLog`, `IRuntimeDumps`, `ISystemMessages` |
36
37
  | `execution/` | 3 | class and program execution, with profiling |
37
38
  | `feeds/` | 2 | the ADT feed contracts |
38
39
  | `service/` | 1 | service definitions and bindings |
39
40
  | `shared/` | 1 | what more than one object type needs |
40
41
 
41
- Six directories, all ADT. `connection/` left for `interfaces-adt-connection` in 11.0.0. `sap/`, `auth/`, `token/`, `session/`, `serviceKey/`, `store/`, `validation/` and `Headers.ts` were here until 9.0.0 and are listed above under what left; `__typechecks__/` holds 29 files that compile shapes this contract must and must not accept, and ships in no tarball.
42
+ Six directories, all ADT. `connection/` left for `interfaces-adt-connection` in 11.0.0. `sap/`, `auth/`, `token/`, `session/`, `serviceKey/`, `store/`, `validation/` and `Headers.ts` were here until 9.0.0 and are listed above under what left; `__typechecks__/` holds 30 files that compile shapes this contract must and must not accept, and ships in no tarball.
42
43
 
43
44
  The contract rules — what a member answers, how a strategy is supplied, how a contract is built — are in [`docs/architecture/ARCHITECTURE.md`](../../docs/architecture/ARCHITECTURE.md). Domain-by-domain documentation with examples used to sit in the facade's README; the facade is deleted, and each package documents its own contracts.
44
45
 
@@ -94,7 +95,16 @@ library reads; `AdtSourceTypeCode` is drawn from it.
94
95
  **What is not in a table is not served.** An API whose every member the 7.40
95
96
  client refuses is absent from `ADT_TYPES_BASIS_740`, and an operation it
96
97
  refuses is absent from its code — 7.40 has no `deletionCheck`, no `transport`,
97
- no `run`. The entry shape (`AdtApiTable<R>`) refuses a misspelt field, an
98
+ no `run`. On ABAP cloud a program and an include are only SAP's own: they
99
+ list what a delivered one answers — reads, checks, the deletion check, the
100
+ enhancement reads and a program's ABAP Unit runs. A read is listed where the
101
+ release's discovery has its endpoint; an operation that changes an object where
102
+ the release offers it (its discovery, and a measurement), and not where a
103
+ measurement on the release refused it. `typestructure`'s `USER_AUTHORIZATIONS`
104
+ is one user's on one system — the type accessible there and the user allowed
105
+ to create it — so it explains a refusal, it does not fill a table. A system's
106
+ own refusal (an authorization, a setting) is its answer at run time.
107
+ The entry shape (`AdtApiTable<R>`) refuses a misspelt field, an
98
108
  operation outside the vocabulary, an API with no factory and another release's
99
109
  evidence at compile time.
100
110
 
@@ -158,6 +168,46 @@ when `[C] extends [AdtParentedTypeCode]` — `IObjectReference<'FUGR/FF'>` —
158
168
  and leaves it optional otherwise, the default included, so a reference built
159
169
  from a code typed `AdtTypeCode` compiles and an interface can extend it.
160
170
 
171
+ ### Intersections, group-only codes and group references (22.0.0)
172
+
173
+ **A union of variants.** `AdtTypeCodeOf<V>`, `AdtTypeCodeWith<V, Op>` and
174
+ `AdtApiWith<V, Op>` read a union of variants as one union table: the APIs all
175
+ of them serve, and for those the codes and operations any of them lists. The
176
+ intersecting helpers ask every variant: `AdtCodeOf<V>` and `AdtCodeWith<V, Op>`
177
+ are the codes every variant of `V` lists (with `Op`), and
178
+ `AdtServingVariantsIn<IAdtTypeTables, A>` and
179
+ `AdtPerformingVariantsIn<IAdtTypeTables, A, Op>` name the variants that serve
180
+ an API or perform an operation on one of its codes — what a client's gates
181
+ need. For `AdtModernVariant`, `'onprem' | 'cloud'`, that is what both tables
182
+ serve. `AdtCodeOfIn` and `AdtCodeWithIn` take any set of tables.
183
+
184
+ **Utility codes.** `ADT_UTILITY_CODES_ONPREM`, `_CLOUD` and `_BASIS_740` hold
185
+ what `getUtils()` takes beyond the API tables, with its operations
186
+ (`AdtUtilityOperation`), whether they were measured, and the evidence:
187
+
188
+ | code | where | operations | measured |
189
+ |---|---|---|---|
190
+ | `VIEW/DV` | every release, `/sap/bc/adt/ddic/views` | group activation, group deletion, where-used | no |
191
+ | `DEVC/K` | S/4HANA 2025, ABAP cloud | group activation | no |
192
+ | `DEVC/K` | SAP_BASIS 7.40 SP04 | node structure | yes |
193
+
194
+ `VIEW/DV` is a **group-only code** (`AdtGroupOnlyCode`): no API serves it, so
195
+ it is no `AdtTypeCode`. `IObjectReference<'VIEW/DV'>` and
196
+ `IGetWhereUsedParams<'VIEW/DV'>` name it; the defaults do not.
197
+
198
+ **Group references.** `IAdtGroupActivationReference<V>`,
199
+ `IAdtGroupDeletionCheckReference<V>`, `IAdtGroupDeletionReference<V>` and
200
+ `IAdtWhereUsedParamsOf<V>` take only the codes their operation sends on `V`
201
+ — no message class in an activation, no package in a 7.40 one, no function
202
+ include in where-used — and require `parentName` for `FUGR/FF` and `FUGR/I`.
203
+ `IAdtTypedGroupLifecycle` and `IAdtTypedWhereUsed` declare the members over
204
+ them, beside `IAdtGroupLifecycle` and `IAdtWhereUsed`: a contract composed of
205
+ both takes typed references and the 21.0.0 `IObjectReference[]` alike.
206
+
207
+ **The type structure.** `IAdtTypeStructure.getTypeStructure({ headers })`
208
+ posts to `/sap/bc/adt/repository/typestructure`; its reading is
209
+ `IUtilResults.typeStructure`, optional so a 21.0.0 set is still one.
210
+
161
211
  ## Enhancements and their hosts
162
212
 
163
213
  `EnhancementType` accepts `enhoxhb` (BAdI implementation, ENHO/XHB), `enhoxhh`
@@ -231,6 +281,40 @@ The field is on each member's own options, not on `IAdtAnalyseOptions` or
231
281
  `IAdtOperationOptions`. `src/__typechecks__/headersOnEveryMember.ts` holds this
232
282
  for every member and every overload.
233
283
 
284
+ ## Migrating to 23.0.0
285
+
286
+ - **ABAP cloud: a delivered program is not transported, run or profiled.**
287
+ `ADT_TYPES_CLOUD` no longer lists `transport`, `run` or `profile` for
288
+ `PROG/P`: on a delivered program the transport answers `404`, and a run or a
289
+ profiled run is refused ("You are not authorized to execute this object",
290
+ measured 2026-10-28). Code gated on the cloud variant, or on the
291
+ intersecting helpers over `AdtModernVariant`, that reads a program's
292
+ transport or runs or profiles a program stops compiling.
293
+ - **ABAP cloud: a feature toggle is only read.** `ADT_TYPES_CLOUD` lists for
294
+ `FTG2/FT` `read`, `source`, `readMetadata`, `check`, `deletionCheck`,
295
+ `getRuntimeState` and `checkState`: the create answers `403` (the cloud's
296
+ `typestructure` gives the measuring user no `CREATE` for it). Code gated
297
+ on the cloud variant, or on the intersecting helpers over
298
+ `AdtModernVariant`, that creates, changes, locks, activates, deletes or
299
+ switches a feature toggle stops compiling.
300
+ - `deletionCheck` is listed again for `PROG/P` and `PROG/I` on ABAP cloud;
301
+ nothing that compiled stops compiling for it.
302
+
303
+ ## Migrating to 22.0.0
304
+
305
+ - **ABAP cloud: no program or include of one's own.** `ADT_TYPES_CLOUD` no
306
+ longer lists `create`, `update`, `lock`, `unlock`, `activate`, `validate`,
307
+ `deletionCheck` or `delete` for `PROG/P` and `PROG/I`: the cloud refuses to
308
+ create either (`403`, S_DEVELOP). Code gated on the cloud variant, or on the
309
+ intersecting helpers over `AdtModernVariant` (`AdtCodeWith`,
310
+ `AdtPerformingVariantsIn` — what both newer tables serve), that creates or
311
+ changes a program or an include stops compiling. The union helpers
312
+ (`AdtApiWith`, `AdtTypeCodeWith`) over `AdtModernVariant` still name the
313
+ program, since on-premise creates one. A function include (`FUGR/I`) is
314
+ unchanged. (23.0.0 lists `deletionCheck` again.)
315
+ - Nothing else breaks: every other change is an addition (see the
316
+ CHANGELOG).
317
+
234
318
  ## Migrating to 21.0.0
235
319
 
236
320
  Every break is a type error; nothing a correct call sends changes.
package/dist/adt/AdtTypeTables.d.ts CHANGED
@@ -17,13 +17,14 @@
17
17
  * Constants and types only: the tables are `as const` and `satisfies` the
18
18
  * entry shape of `IAdtTypeTable.ts`, and everything below them is derived.
19
19
  */
20
- import type { AdtCheckedTable, AdtOperation, IAdtCodelessApiEntry } from './IAdtTypeTable';
20
+ import type { AdtApiName, AdtCheckedTable, AdtOperation, IAdtCodelessApiEntry } from './IAdtTypeTable';
21
21
  /**
22
22
  * What the library serves on **S/4HANA 2025 on-premise**, API by API.
23
23
  *
24
- * Identical in operations to {@link ADT_TYPES_CLOUD}: the library has no
25
- * on-premise or cloud branch. The two differ where the releases do —
26
- * `SRVD/SRV` takes 40 characters here and 30 on ABAP cloud.
24
+ * The library has no on-premise or cloud branch; the two tables differ where
25
+ * the releases do — `SRVD/SRV` takes 40 characters here and 30 on ABAP
26
+ * cloud, and a program or an include is created and changed, a program run,
27
+ * and a feature toggle created, changed and switched, only here.
27
28
  */
28
29
  export declare const ADT_TYPES_ONPREM: {
29
30
  readonly class: {
@@ -33,7 +34,7 @@ export declare const ADT_TYPES_ONPREM: {
33
34
  readonly 'CLAS/OC': {
34
35
  readonly parent: null;
35
36
  readonly nameMaxLength: 30;
36
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "readEnhancementElements", "readEnhancementOptions", "activateTestClasses", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
37
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "readEnhancementElements", "readEnhancementOptions", "activateTestClasses", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
37
38
  readonly evidence: "system-description-s4-2025--07-typestructure";
38
39
  };
39
40
  };
@@ -45,7 +46,7 @@ export declare const ADT_TYPES_ONPREM: {
45
46
  readonly 'INTF/OI': {
46
47
  readonly parent: null;
47
48
  readonly nameMaxLength: 30;
48
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
49
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
49
50
  readonly evidence: "system-description-s4-2025--07-typestructure";
50
51
  };
51
52
  };
@@ -57,7 +58,7 @@ export declare const ADT_TYPES_ONPREM: {
57
58
  readonly 'PROG/P': {
58
59
  readonly parent: null;
59
60
  readonly nameMaxLength: 40;
60
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "readEnhancementElements", "readEnhancementOptions", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
61
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "readEnhancementElements", "readEnhancementOptions", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
61
62
  readonly evidence: "system-description-s4-2025--07-typestructure";
62
63
  };
63
64
  };
@@ -93,7 +94,7 @@ export declare const ADT_TYPES_ONPREM: {
93
94
  readonly 'FUGR/FF': {
94
95
  readonly parent: "functionGroup";
95
96
  readonly nameMaxLength: 30;
96
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
97
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
97
98
  readonly evidence: "system-description-s4-2025--07-typestructure";
98
99
  };
99
100
  };
@@ -129,7 +130,7 @@ export declare const ADT_TYPES_ONPREM: {
129
130
  readonly 'DDLS/DF': {
130
131
  readonly parent: null;
131
132
  readonly nameMaxLength: 30;
132
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
133
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
133
134
  readonly evidence: "system-description-s4-2025--07-typestructure";
134
135
  };
135
136
  };
@@ -433,7 +434,23 @@ export declare const ADT_TYPES_ONPREM: {
433
434
  /**
434
435
  * What the library serves on **ABAP cloud** (measured on the BTP trial), API by
435
436
  * API. The same operations as {@link ADT_TYPES_ONPREM}, and this release's
436
- * name lengths.
437
+ * name lengths, but for a program (`PROG/P`), an include (`PROG/I`) and a
438
+ * feature toggle (`FTG2/FT`), each only read here. The cloud has no program
439
+ * or include of one's own — its discovery gives neither collection an
440
+ * `app:accept`, and the create is refused (`403`, S_DEVELOP) — so they list
441
+ * what a delivered one answers (measured): the reads, the check, the versions,
442
+ * the deletion check, the enhancement reads and, for a program, the ABAP Unit
443
+ * runs. Its transport is `404`, and running or profiling it is refused.
444
+ *
445
+ * A read is listed where the release's discovery has its endpoint. An
446
+ * operation that changes an object (`create`, `update`, `updateMetadata`,
447
+ * `lock`, `unlock`, `activate`, `delete`, a feature toggle's switch, and the
448
+ * `validate` that prepares a create) is listed where the release offers it —
449
+ * its discovery, and a measurement — and left out where a measurement on the
450
+ * release refused it: a feature toggle (`FTG2/FT`) is only read here, while a
451
+ * function include (`FUGR/I`) is created in its group. `typestructure`'s
452
+ * `USER_AUTHORIZATIONS` says why a measuring user was refused, for that user
453
+ * on that system; it explains the table, it does not fill it.
437
454
  */
438
455
  export declare const ADT_TYPES_CLOUD: {
439
456
  readonly class: {
@@ -443,7 +460,7 @@ export declare const ADT_TYPES_CLOUD: {
443
460
  readonly 'CLAS/OC': {
444
461
  readonly parent: null;
445
462
  readonly nameMaxLength: 30;
446
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "readEnhancementElements", "readEnhancementOptions", "activateTestClasses", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
463
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "readEnhancementElements", "readEnhancementOptions", "activateTestClasses", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
447
464
  readonly evidence: "system-description-abap-cloud--07-typestructure";
448
465
  };
449
466
  };
@@ -455,7 +472,7 @@ export declare const ADT_TYPES_CLOUD: {
455
472
  readonly 'INTF/OI': {
456
473
  readonly parent: null;
457
474
  readonly nameMaxLength: 30;
458
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
475
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
459
476
  readonly evidence: "system-description-abap-cloud--07-typestructure";
460
477
  };
461
478
  };
@@ -467,7 +484,7 @@ export declare const ADT_TYPES_CLOUD: {
467
484
  readonly 'PROG/P': {
468
485
  readonly parent: null;
469
486
  readonly nameMaxLength: 40;
470
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "readEnhancementElements", "readEnhancementOptions", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
487
+ readonly operations: readonly ["read", "source", "readMetadata", "check", "versions", "deletionCheck", "readEnhancementElements", "readEnhancementOptions", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
471
488
  readonly evidence: "system-description-abap-cloud--07-typestructure";
472
489
  };
473
490
  };
@@ -479,7 +496,7 @@ export declare const ADT_TYPES_CLOUD: {
479
496
  readonly 'PROG/I': {
480
497
  readonly parent: null;
481
498
  readonly nameMaxLength: 40;
482
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "validate", "deletionCheck", "delete", "readEnhancementElements", "readEnhancementOptions"];
499
+ readonly operations: readonly ["read", "source", "readMetadata", "deletionCheck", "readEnhancementElements", "readEnhancementOptions"];
483
500
  readonly evidence: "system-description-abap-cloud--07-typestructure";
484
501
  };
485
502
  };
@@ -503,7 +520,7 @@ export declare const ADT_TYPES_CLOUD: {
503
520
  readonly 'FUGR/FF': {
504
521
  readonly parent: "functionGroup";
505
522
  readonly nameMaxLength: 30;
506
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
523
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
507
524
  readonly evidence: "system-description-abap-cloud--07-typestructure";
508
525
  };
509
526
  };
@@ -539,7 +556,7 @@ export declare const ADT_TYPES_CLOUD: {
539
556
  readonly 'DDLS/DF': {
540
557
  readonly parent: null;
541
558
  readonly nameMaxLength: 30;
542
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
559
+ readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
543
560
  readonly evidence: "system-description-abap-cloud--07-typestructure";
544
561
  };
545
562
  };
@@ -755,7 +772,7 @@ export declare const ADT_TYPES_CLOUD: {
755
772
  readonly 'FTG2/FT': {
756
773
  readonly parent: null;
757
774
  readonly nameMaxLength: 30;
758
- readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "deletionCheck", "delete", "switchOn", "switchOff", "getRuntimeState", "checkState"];
775
+ readonly operations: readonly ["read", "source", "readMetadata", "check", "deletionCheck", "getRuntimeState", "checkState"];
759
776
  readonly evidence: "system-description-abap-cloud--07-typestructure";
760
777
  };
761
778
  };
@@ -1016,6 +1033,12 @@ export declare const ADT_TYPES_BASIS_740: {
1016
1033
  * `basis740` SAP_BASIS 7.40 SP04. Declared by the consumer, never detected.
1017
1034
  */
1018
1035
  export type AdtVariant = 'onprem' | 'cloud' | 'basis740';
1036
+ /**
1037
+ * A system of SAP_BASIS 7.50 or later, on premise or ABAP cloud — the variant
1038
+ * a client serves when none is named. Read with the intersecting helpers
1039
+ * below, it gets what **both** tables serve.
1040
+ */
1041
+ export type AdtModernVariant = Exclude<AdtVariant, 'basis740'>;
1019
1042
  /** The table of each variant, by its name. */
1020
1043
  export interface IAdtTypeTables {
1021
1044
  readonly onprem: AdtCheckedTable<typeof ADT_TYPES_ONPREM>;
@@ -1043,9 +1066,20 @@ type ParentedCodesOf<E> = E extends {
1043
1066
  readonly parent: null;
1044
1067
  } ? never : K;
1045
1068
  }[keyof C] & string : never;
1046
- /** The APIs — the client's factories — variant `V` serves. */
1069
+ /**
1070
+ * The APIs — the client's factories — variant `V` serves. For a union of
1071
+ * variants this is already the intersection: `keyof` a union of tables names
1072
+ * the APIs every one of them holds.
1073
+ */
1047
1074
  export type AdtApi<V extends AdtVariant> = keyof TableOf<V>;
1048
- /** The type codes variant `V` serves. */
1075
+ /**
1076
+ * The type codes variant `V` serves.
1077
+ *
1078
+ * **Union semantics within the shared APIs.** For a union of variants it
1079
+ * reads the tables as one union table: the APIs every one of them serves
1080
+ * (`keyof` a union), and for those the codes *any* of them lists.
1081
+ * {@link AdtCodeOf} is the intersection.
1082
+ */
1049
1083
  export type AdtTypeCodeOf<V extends AdtVariant> = {
1050
1084
  [A in AdtApi<V>]: CodesOf<TableOf<V>[A]>;
1051
1085
  }[AdtApi<V>];
@@ -1055,19 +1089,34 @@ export type AdtTypeCode = {
1055
1089
  }[AdtVariant];
1056
1090
  /**
1057
1091
  * The APIs of table `T` one code of which performs every operation of `Op` —
1092
+ * for a union of tables, **union semantics within the shared APIs**: an API
1093
+ * every table holds qualifies when one table's entry does (see
1094
+ * {@link AdtPerformingVariantsIn} for the intersecting question) —
1058
1095
  * or, for a codeless API, whose entry does. Operations spread across two codes
1059
1096
  * do not count: no single object of the API could be asked for all of them.
1060
1097
  */
1061
1098
  export type AdtApiWithIn<T, Op extends AdtOperation> = {
1062
1099
  [A in keyof T]: EntryHas<T[A], Op> extends true ? A : never;
1063
1100
  }[keyof T];
1064
- /** {@link AdtApiWithIn} over variant `V`'s table. */
1101
+ /**
1102
+ * {@link AdtApiWithIn} over variant `V`'s table — for a union of variants,
1103
+ * **union semantics within the shared APIs**: an API all of them serve
1104
+ * qualifies when one variant's table has it so.
1105
+ */
1065
1106
  export type AdtApiWith<V extends AdtVariant, Op extends AdtOperation> = AdtApiWithIn<TableOf<V>, Op>;
1066
- /** The codes of variant `V` whose facts list every operation of `Op`. */
1107
+ /**
1108
+ * The codes of variant `V` whose facts list every operation of `Op` — for a
1109
+ * union of variants, **union semantics within the shared APIs**: a code of an
1110
+ * API all of them serve, listed with `Op` by any of them. {@link AdtCodeWith}
1111
+ * is the intersection.
1112
+ */
1067
1113
  export type AdtTypeCodeWith<V extends AdtVariant, Op extends AdtOperation> = {
1068
1114
  [A in AdtApi<V>]: CodesWith<TableOf<V>[A], Op>;
1069
1115
  }[AdtApi<V>];
1070
- /** Every kind of any table — the tools' one vocabulary for objects. */
1116
+ /**
1117
+ * Every kind of any table — the tools' one vocabulary for objects. A union
1118
+ * over all variants by design.
1119
+ */
1071
1120
  export type AdtObjectKind = {
1072
1121
  [V in AdtVariant]: {
1073
1122
  [A in AdtApi<V>]: TableOf<V>[A] extends {
@@ -1075,7 +1124,11 @@ export type AdtObjectKind = {
1075
1124
  } ? K : never;
1076
1125
  }[AdtApi<V>];
1077
1126
  }[AdtVariant];
1078
- /** The codes, of any table, whose API reads a source there (`source`). */
1127
+ /**
1128
+ * The codes, of any table, whose API reads a source there (`source`) — a union
1129
+ * over all variants by design. A variant's own, intersected for a union of
1130
+ * variants, is `AdtCodeWith<V, 'source'>`.
1131
+ */
1079
1132
  export type AdtSourceTypeCode = {
1080
1133
  [V in AdtVariant]: AdtTypeCodeWith<V, 'source'>;
1081
1134
  }[AdtVariant];
@@ -1088,5 +1141,62 @@ export type AdtParentedTypeCode = {
1088
1141
  [A in AdtApi<V>]: ParentedCodesOf<TableOf<V>[A]>;
1089
1142
  }[AdtApi<V>];
1090
1143
  }[AdtVariant];
1144
+ type CodesOfTable<T> = {
1145
+ [A in keyof T]: CodesOf<T[A]>;
1146
+ }[keyof T];
1147
+ type CodesWithInTable<T, Op extends AdtOperation> = {
1148
+ [A in keyof T]: CodesWith<T[A], Op>;
1149
+ }[keyof T];
1150
+ /** The variants, among `Tables`' keys, whose table lists code `C`. */
1151
+ type VariantsListingIn<Tables, C> = {
1152
+ [W in keyof Tables]: C extends CodesOfTable<Tables[W]> ? W : never;
1153
+ }[keyof Tables];
1154
+ /** The variants, among `Tables`' keys, whose table lists `Op` for code `C`. */
1155
+ type VariantsWhereCodeHasIn<Tables, C, Op extends AdtOperation> = {
1156
+ [W in keyof Tables]: C extends CodesWithInTable<Tables[W], Op> ? W : never;
1157
+ }[keyof Tables];
1158
+ /**
1159
+ * The variants, among `Tables`' keys, whose table serves API `A`. Each key is
1160
+ * read on its own table, so nothing distributes over a union of tables.
1161
+ */
1162
+ export type AdtServingVariantsIn<Tables, A extends AdtApiName> = {
1163
+ [W in keyof Tables]: A extends keyof Tables[W] ? W : never;
1164
+ }[keyof Tables];
1165
+ /**
1166
+ * The variants, among `Tables`' keys, one code of whose API `A` lists every
1167
+ * operation of `Op` (or, for a codeless API, whose entry does).
1168
+ */
1169
+ export type AdtPerformingVariantsIn<Tables, A extends AdtApiName, Op extends AdtOperation> = {
1170
+ [W in keyof Tables]: [A] extends [AdtApiWithIn<Tables[W], Op>] ? W : never;
1171
+ }[keyof Tables];
1172
+ /** The codes any table of `V` lists — the candidates, each table read alone. */
1173
+ type CandidateCodes<Tables, V extends keyof Tables> = {
1174
+ [W in V]: CodesOfTable<Tables[W]>;
1175
+ }[V];
1176
+ /** The codes any table of `V` lists `Op` for, each table read alone. */
1177
+ type CandidateCodesWith<Tables, V extends keyof Tables, Op extends AdtOperation> = {
1178
+ [W in V]: CodesWithInTable<Tables[W], Op>;
1179
+ }[V];
1180
+ /** The codes every table of `V` among `Tables` lists: the intersection. */
1181
+ export type AdtCodeOfIn<Tables, V extends keyof Tables> = {
1182
+ [C in CandidateCodes<Tables, V>]: [V] extends [VariantsListingIn<Tables, C>] ? C : never;
1183
+ }[CandidateCodes<Tables, V>];
1184
+ /** The codes for which every table of `V` among `Tables` lists `Op`. */
1185
+ export type AdtCodeWithIn<Tables, V extends keyof Tables, Op extends AdtOperation> = {
1186
+ [C in CandidateCodesWith<Tables, V, Op>]: [V] extends [
1187
+ VariantsWhereCodeHasIn<Tables, C, Op>
1188
+ ] ? C : never;
1189
+ }[CandidateCodesWith<Tables, V, Op>];
1190
+ /**
1191
+ * The codes every variant of `V` lists — for the default modern variant, the
1192
+ * codes both newer tables list. The intersecting counterpart of
1193
+ * {@link AdtTypeCodeOf}.
1194
+ */
1195
+ export type AdtCodeOf<V extends AdtVariant> = AdtCodeOfIn<IAdtTypeTables, V>;
1196
+ /**
1197
+ * The codes for which every variant of `V` lists every operation of `Op` —
1198
+ * the intersecting counterpart of {@link AdtTypeCodeWith}.
1199
+ */
1200
+ export type AdtCodeWith<V extends AdtVariant, Op extends AdtOperation> = AdtCodeWithIn<IAdtTypeTables, V, Op>;
1091
1201
  export {};
1092
1202
  //# sourceMappingURL=AdtTypeTables.d.ts.map
package/dist/adt/AdtTypeTables.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"AdtTypeTables.d.ts","sourceRoot":"","sources":["../../src/adt/AdtTypeTables.ts"],"names":[],"mappings":"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"}
1
+ {"version":3,"file":"AdtTypeTables.d.ts","sourceRoot":"","sources":["../../src/adt/AdtTypeTables.ts"],"names":[],"mappings":"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"}