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

package/CHANGELOG.md

@@ -7,6 +7,89 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [22.0.0] - 2026-10-28
+
+A major for one change: the ABAP cloud table loses the program and include
+operations the cloud refuses (see "Changed (breaking)"). Everything else is
+added beside 21.0.0's types: each keeps its meaning, and a type parameter
+added to an existing type has the 21.0.0 type as its default.
+
+### Changed (breaking)
+
+- **`ADT_TYPES_CLOUD`: a program and an include change nothing.** ABAP cloud
+  refuses to create either (`403`, S_DEVELOP, measured on the BTP trial
+  2026-10-28), so `PROG/P` and `PROG/I` no longer list `create`, `update`,
+  `lock`, `unlock`, `activate`, `validate`, `deletionCheck` or `delete`.
+  What a delivered one answers stays: `read`, `source` and `readMetadata`
+  (measured on both), `check` and `versions` for a program (measured),
+  and the operations not measured — the enhancement reads, `transport`,
+  `run`, `profile` and the unit-test runs — as the release's `typestructure`
+  lists them. Leaving out the change operations beyond `create` is an
+  inference from the refusal: S_DEVELOP is the change authorization, and an
+  object nobody can create has nothing of one's own to change. A function
+  include (`FUGR/I`) is unchanged: the cloud creates one (`200`, measured).
+  `AdtTypeCodeWith<'cloud', Op>` and `AdtCodeWith<AdtModernVariant, Op>` no
+  longer name `PROG/P` or `PROG/I` for those operations, and the cloud table
+  is no longer the on-premise one in operations.
+
+### Added
+
+- **`updateMetadata`** on `CLAS/OC`, `INTF/OI`, `FUGR/FF` and `DDLS/DF` in
+  `ADT_TYPES_ONPREM` and `ADT_TYPES_CLOUD`, and on `PROG/P` in
+  `ADT_TYPES_ONPREM`: the object's whole metadata document, written back with
+  the media type it was read with, answers `200` on S/4HANA 2025 and on ABAP
+  cloud (measured 2026-10-27). 7.40 is not measured yet and keeps none.
+
+- **Intersecting helpers.** `AdtCodeOf<V>` and `AdtCodeWith<V, Op>`: the codes
+  every variant of `V` lists (with `Op`) — the default modern variant,
+  `AdtModernVariant` (`'onprem' | 'cloud'`), gets what both newer tables
+  serve. `AdtCodeOfIn<Tables, V>` and `AdtCodeWithIn<Tables, V, Op>` are the
+  same over any set of tables; `AdtServingVariantsIn<Tables, A>` and
+  `AdtPerformingVariantsIn<Tables, A, Op>` name the variants whose table
+  serves an API, or one of its codes an operation. `AdtTypeCodeOf`,
+  `AdtTypeCodeWith`, `AdtApiWith` and `AdtApiWithIn` are unchanged; their docs
+  now state what they answer for a union of variants — the APIs all of them
+  serve, and for those the codes and operations any of them lists.
+- **Utility code tables**, `ADT_UTILITY_CODES_ONPREM`, `_CLOUD`,
+  `_BASIS_740` (`IAdtUtilityCodeTables`, `AdtUtilityCodeTable<R>`,
+  `IAdtUtilityCodeFacts<R>`, `AdtUtilityOperation`, `AdtUtilityCodeWith<V,
+  Op>`, `AdtUtilityCode`): the codes `getUtils()` takes beyond the API tables,
+  each with its operations, whether they were measured, and its evidence.
+  - `VIEW/DV`, a DDIC database view, on every release: group activation,
+    group deletion and where-used, under `/sap/bc/adt/ddic/views`. No API
+    serves it — a **group-only code**, `AdtGroupOnlyCode`,
+    `AdtGroupOnlyCodeOf<V>`. Sent, unmeasured.
+  - `DEVC/K` in a group activation on the newer releases — sent, unmeasured.
+  - `DEVC/K` in `fetchNodeStructure` on 7.40 — measured (the legacy
+    `UtilsReaders` cycle). A table of its own rather than a package entry on
+    7.40, because an entry would gate `getPackage()` open where every package
+    member is refused, and a new `AdtOperation` word would break a 21.0.0
+    consumer's exhaustive map over the vocabulary.
+- `IObjectReference<C>`, `IGetWhereUsedParams<C>` and
+  `IGetWhereUsedScopeParams<C>` take a group-only code as their type
+  argument (`IObjectReference<'VIEW/DV'>`). Their defaults are 21.0.0's: a
+  bare `IObjectReference` still admits `AdtTypeCode` alone.
+- **What each group operation is given:** `AdtGroupActivationCode<V>`,
+  `AdtGroupDeletionCheckCode<V>`, `AdtGroupDeletionCode<V>` (no `MSAG/NN`,
+  which has no address of its own), `AdtWhereUsedCode<V>` (no `FUGR/I` or
+  `MSAG/NN`), and the references over them, `IAdtGroupActivationReference<V>`,
+  `IAdtGroupDeletionCheckReference<V>`, `IAdtGroupDeletionReference<V>`,
+  `IAdtWhereUsedParamsOf<V>`, `IAdtWhereUsedScopeParamsOf<V>`, built by
+  `IAdtCodedReference<C>`: `parentName` required for each parented code, and
+  a reference from a code known only by its set compiles when it names its
+  parent — inside TypeScript's 25-combination limit.
+- `IAdtTypedGroupLifecycle<TActivation, TDeletionCheck, TDeletion, V>` and
+  `IAdtTypedWhereUsed<TWhereUsed, TScope, V>`: the group and where-used members
+  over those references. New atoms beside `IAdtGroupLifecycle` and
+  `IAdtWhereUsed`, with the same member names: an implementation declaring
+  both offers both signatures, and a caller passing `IObjectReference[]` is
+  unaffected. Adding the signatures to the 21.0.0 atoms instead would have
+  made every implementation of them stop compiling.
+- `IAdtTypeStructure<TTypeStructure>`: `getTypeStructure({ headers })`,
+  `POST /sap/bc/adt/repository/typestructure`, an atom of its own like
+  `IAdtObjectProperties`, and `IUtilResults.typeStructure`, its reading —
+  optional, so a 21.0.0 result set is still one.
+
 ## [21.0.0] - 2026-10-27
 
 ### Added

package/README.md

@@ -11,6 +11,7 @@ ADT contracts: object operations, runtime analysis, execution, feeds and service
 - 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.
 - 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.
 - 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.
+- Since 22.0.0, the ABAP cloud table creates and changes no program or include (`403`, S_DEVELOP; see "Migrating to 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".
 - 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".
 - 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.
 - 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
 
 | directory | files | what |
 |---|---|---|
-| `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 |
+| `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 |
 | `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` |
 | `execution/` | 3 | class and program execution, with profiling |
 | `feeds/` | 2 | the ADT feed contracts |
 | `service/` | 1 | service definitions and bindings |
 | `shared/` | 1 | what more than one object type needs |
 
-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.
+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.
 
 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.
 
@@ -94,7 +95,8 @@ library reads; `AdtSourceTypeCode` is drawn from it.
 **What is not in a table is not served.** An API whose every member the 7.40
 client refuses is absent from `ADT_TYPES_BASIS_740`, and an operation it
 refuses is absent from its code — 7.40 has no `deletionCheck`, no `transport`,
-no `run`. The entry shape (`AdtApiTable<R>`) refuses a misspelt field, an
+no `run`. On ABAP cloud a program and an include list no operation that
+changes an object, since the cloud refuses to create either. The entry shape (`AdtApiTable<R>`) refuses a misspelt field, an
 operation outside the vocabulary, an API with no factory and another release's
 evidence at compile time.
 
@@ -158,6 +160,46 @@ when `[C] extends [AdtParentedTypeCode]` — `IObjectReference<'FUGR/FF'>` —
 and leaves it optional otherwise, the default included, so a reference built
 from a code typed `AdtTypeCode` compiles and an interface can extend it.
 
+### Intersections, group-only codes and group references (22.0.0)
+
+**A union of variants.** `AdtTypeCodeOf<V>`, `AdtTypeCodeWith<V, Op>` and
+`AdtApiWith<V, Op>` read a union of variants as one union table: the APIs all
+of them serve, and for those the codes and operations any of them lists. The
+intersecting helpers ask every variant: `AdtCodeOf<V>` and `AdtCodeWith<V, Op>`
+are the codes every variant of `V` lists (with `Op`), and
+`AdtServingVariantsIn<IAdtTypeTables, A>` and
+`AdtPerformingVariantsIn<IAdtTypeTables, A, Op>` name the variants that serve
+an API or perform an operation on one of its codes — what a client's gates
+need. For `AdtModernVariant`, `'onprem' | 'cloud'`, that is what both tables
+serve. `AdtCodeOfIn` and `AdtCodeWithIn` take any set of tables.
+
+**Utility codes.** `ADT_UTILITY_CODES_ONPREM`, `_CLOUD` and `_BASIS_740` hold
+what `getUtils()` takes beyond the API tables, with its operations
+(`AdtUtilityOperation`), whether they were measured, and the evidence:
+
+| code | where | operations | measured |
+|---|---|---|---|
+| `VIEW/DV` | every release, `/sap/bc/adt/ddic/views` | group activation, group deletion, where-used | no |
+| `DEVC/K` | S/4HANA 2025, ABAP cloud | group activation | no |
+| `DEVC/K` | SAP_BASIS 7.40 SP04 | node structure | yes |
+
+`VIEW/DV` is a **group-only code** (`AdtGroupOnlyCode`): no API serves it, so
+it is no `AdtTypeCode`. `IObjectReference<'VIEW/DV'>` and
+`IGetWhereUsedParams<'VIEW/DV'>` name it; the defaults do not.
+
+**Group references.** `IAdtGroupActivationReference<V>`,
+`IAdtGroupDeletionCheckReference<V>`, `IAdtGroupDeletionReference<V>` and
+`IAdtWhereUsedParamsOf<V>` take only the codes their operation sends on `V`
+— no message class in an activation, no package in a 7.40 one, no function
+include in where-used — and require `parentName` for `FUGR/FF` and `FUGR/I`.
+`IAdtTypedGroupLifecycle` and `IAdtTypedWhereUsed` declare the members over
+them, beside `IAdtGroupLifecycle` and `IAdtWhereUsed`: a contract composed of
+both takes typed references and the 21.0.0 `IObjectReference[]` alike.
+
+**The type structure.** `IAdtTypeStructure.getTypeStructure({ headers })`
+posts to `/sap/bc/adt/repository/typestructure`; its reading is
+`IUtilResults.typeStructure`, optional so a 21.0.0 set is still one.
+
 ## Enhancements and their hosts
 
 `EnhancementType` accepts `enhoxhb` (BAdI implementation, ENHO/XHB), `enhoxhh`
@@ -231,6 +273,22 @@ The field is on each member's own options, not on `IAdtAnalyseOptions` or
 `IAdtOperationOptions`. `src/__typechecks__/headersOnEveryMember.ts` holds this
 for every member and every overload.
 
+## Migrating to 22.0.0
+
+- **ABAP cloud: no program or include of one's own.** `ADT_TYPES_CLOUD` no
+  longer lists `create`, `update`, `lock`, `unlock`, `activate`, `validate`,
+  `deletionCheck` or `delete` for `PROG/P` and `PROG/I`: the cloud refuses to
+  create either (`403`, S_DEVELOP). Code gated on the cloud variant, or on
+  the intersecting helpers over `AdtModernVariant` (`AdtCodeWith`,
+  `AdtPerformingVariantsIn` — what both newer tables serve), that creates or
+  changes a program or an include stops compiling; on ABAP cloud the system
+  would have refused it. The union helpers (`AdtApiWith`, `AdtTypeCodeWith`)
+  over `AdtModernVariant` still name the program, since on-premise creates
+  one. Reading, checking and versioning a delivered program
+  compile as before. A function include (`FUGR/I`) is unchanged.
+- Nothing else breaks: every other change is an addition (see the
+  CHANGELOG).
+
 ## Migrating to 21.0.0
 
 Every break is a type error; nothing a correct call sends changes.

package/dist/adt/AdtTypeTables.d.ts

@@ -17,13 +17,13 @@
  * Constants and types only: the tables are `as const` and `satisfies` the
  * entry shape of `IAdtTypeTable.ts`, and everything below them is derived.
  */
-import type { AdtCheckedTable, AdtOperation, IAdtCodelessApiEntry } from './IAdtTypeTable';
+import type { AdtApiName, AdtCheckedTable, AdtOperation, IAdtCodelessApiEntry } from './IAdtTypeTable';
 /**
  * What the library serves on **S/4HANA 2025 on-premise**, API by API.
  *
- * Identical in operations to {@link ADT_TYPES_CLOUD}: the library has no
- * on-premise or cloud branch. The two differ where the releases do —
- * `SRVD/SRV` takes 40 characters here and 30 on ABAP cloud.
+ * The library has no on-premise or cloud branch; the two tables differ where
+ * the releases do — `SRVD/SRV` takes 40 characters here and 30 on ABAP
+ * cloud, and a program or an include is created and changed only here.
  */
 export declare const ADT_TYPES_ONPREM: {
     readonly class: {
@@ -33,7 +33,7 @@ export declare const ADT_TYPES_ONPREM: {
             readonly 'CLAS/OC': {
                 readonly parent: null;
                 readonly nameMaxLength: 30;
-                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"];
+                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"];
                 readonly evidence: "system-description-s4-2025--07-typestructure";
             };
         };
@@ -45,7 +45,7 @@ export declare const ADT_TYPES_ONPREM: {
             readonly 'INTF/OI': {
                 readonly parent: null;
                 readonly nameMaxLength: 30;
-                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
+                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
                 readonly evidence: "system-description-s4-2025--07-typestructure";
             };
         };
@@ -57,7 +57,7 @@ export declare const ADT_TYPES_ONPREM: {
             readonly 'PROG/P': {
                 readonly parent: null;
                 readonly nameMaxLength: 40;
-                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"];
+                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"];
                 readonly evidence: "system-description-s4-2025--07-typestructure";
             };
         };
@@ -93,7 +93,7 @@ export declare const ADT_TYPES_ONPREM: {
             readonly 'FUGR/FF': {
                 readonly parent: "functionGroup";
                 readonly nameMaxLength: 30;
-                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
+                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
                 readonly evidence: "system-description-s4-2025--07-typestructure";
             };
         };
@@ -129,7 +129,7 @@ export declare const ADT_TYPES_ONPREM: {
             readonly 'DDLS/DF': {
                 readonly parent: null;
                 readonly nameMaxLength: 30;
-                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
+                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
                 readonly evidence: "system-description-s4-2025--07-typestructure";
             };
         };
@@ -433,7 +433,9 @@ export declare const ADT_TYPES_ONPREM: {
 /**
  * What the library serves on **ABAP cloud** (measured on the BTP trial), API by
  * API. The same operations as {@link ADT_TYPES_ONPREM}, and this release's
- * name lengths.
+ * name lengths, but for a program (`PROG/P`) and an include (`PROG/I`): the
+ * cloud refuses to create either (`403`, S_DEVELOP), so they list only what a
+ * delivered one answers — nothing that changes an object.
  */
 export declare const ADT_TYPES_CLOUD: {
     readonly class: {
@@ -443,7 +445,7 @@ export declare const ADT_TYPES_CLOUD: {
             readonly 'CLAS/OC': {
                 readonly parent: null;
                 readonly nameMaxLength: 30;
-                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"];
+                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"];
                 readonly evidence: "system-description-abap-cloud--07-typestructure";
             };
         };
@@ -455,7 +457,7 @@ export declare const ADT_TYPES_CLOUD: {
             readonly 'INTF/OI': {
                 readonly parent: null;
                 readonly nameMaxLength: 30;
-                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
+                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport"];
                 readonly evidence: "system-description-abap-cloud--07-typestructure";
             };
         };
@@ -467,7 +469,7 @@ export declare const ADT_TYPES_CLOUD: {
             readonly 'PROG/P': {
                 readonly parent: null;
                 readonly nameMaxLength: 40;
-                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"];
+                readonly operations: readonly ["read", "source", "readMetadata", "check", "versions", "transport", "readEnhancementElements", "readEnhancementOptions", "run", "profile", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
                 readonly evidence: "system-description-abap-cloud--07-typestructure";
             };
         };
@@ -479,7 +481,7 @@ export declare const ADT_TYPES_CLOUD: {
             readonly 'PROG/I': {
                 readonly parent: null;
                 readonly nameMaxLength: 40;
-                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "validate", "deletionCheck", "delete", "readEnhancementElements", "readEnhancementOptions"];
+                readonly operations: readonly ["read", "source", "readMetadata", "readEnhancementElements", "readEnhancementOptions"];
                 readonly evidence: "system-description-abap-cloud--07-typestructure";
             };
         };
@@ -503,7 +505,7 @@ export declare const ADT_TYPES_CLOUD: {
             readonly 'FUGR/FF': {
                 readonly parent: "functionGroup";
                 readonly nameMaxLength: 30;
-                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
+                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "unitTestRun", "unitTestRunSync", "unitTestStatus", "unitTestResult"];
                 readonly evidence: "system-description-abap-cloud--07-typestructure";
             };
         };
@@ -539,7 +541,7 @@ export declare const ADT_TYPES_CLOUD: {
             readonly 'DDLS/DF': {
                 readonly parent: null;
                 readonly nameMaxLength: 30;
-                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
+                readonly operations: readonly ["create", "read", "source", "readMetadata", "update", "updateMetadata", "lock", "unlock", "activate", "check", "validate", "versions", "deletionCheck", "delete", "transport", "checkCdsTestDoubles"];
                 readonly evidence: "system-description-abap-cloud--07-typestructure";
             };
         };
@@ -1016,6 +1018,12 @@ export declare const ADT_TYPES_BASIS_740: {
  * `basis740` SAP_BASIS 7.40 SP04. Declared by the consumer, never detected.
  */
 export type AdtVariant = 'onprem' | 'cloud' | 'basis740';
+/**
+ * A system of SAP_BASIS 7.50 or later, on premise or ABAP cloud — the variant
+ * a client serves when none is named. Read with the intersecting helpers
+ * below, it gets what **both** tables serve.
+ */
+export type AdtModernVariant = Exclude<AdtVariant, 'basis740'>;
 /** The table of each variant, by its name. */
 export interface IAdtTypeTables {
     readonly onprem: AdtCheckedTable<typeof ADT_TYPES_ONPREM>;
@@ -1043,9 +1051,20 @@ type ParentedCodesOf<E> = E extends {
         readonly parent: null;
     } ? never : K;
 }[keyof C] & string : never;
-/** The APIs — the client's factories — variant `V` serves. */
+/**
+ * The APIs — the client's factories — variant `V` serves. For a union of
+ * variants this is already the intersection: `keyof` a union of tables names
+ * the APIs every one of them holds.
+ */
 export type AdtApi<V extends AdtVariant> = keyof TableOf<V>;
-/** The type codes variant `V` serves. */
+/**
+ * The type codes variant `V` serves.
+ *
+ * **Union semantics within the shared APIs.** For a union of variants it
+ * reads the tables as one union table: the APIs every one of them serves
+ * (`keyof` a union), and for those the codes *any* of them lists.
+ * {@link AdtCodeOf} is the intersection.
+ */
 export type AdtTypeCodeOf<V extends AdtVariant> = {
     [A in AdtApi<V>]: CodesOf<TableOf<V>[A]>;
 }[AdtApi<V>];
@@ -1055,19 +1074,34 @@ export type AdtTypeCode = {
 }[AdtVariant];
 /**
  * The APIs of table `T` one code of which performs every operation of `Op` —
+ * for a union of tables, **union semantics within the shared APIs**: an API
+ * every table holds qualifies when one table's entry does (see
+ * {@link AdtPerformingVariantsIn} for the intersecting question) —
  * or, for a codeless API, whose entry does. Operations spread across two codes
  * do not count: no single object of the API could be asked for all of them.
  */
 export type AdtApiWithIn<T, Op extends AdtOperation> = {
     [A in keyof T]: EntryHas<T[A], Op> extends true ? A : never;
 }[keyof T];
-/** {@link AdtApiWithIn} over variant `V`'s table. */
+/**
+ * {@link AdtApiWithIn} over variant `V`'s table — for a union of variants,
+ * **union semantics within the shared APIs**: an API all of them serve
+ * qualifies when one variant's table has it so.
+ */
 export type AdtApiWith<V extends AdtVariant, Op extends AdtOperation> = AdtApiWithIn<TableOf<V>, Op>;
-/** The codes of variant `V` whose facts list every operation of `Op`. */
+/**
+ * The codes of variant `V` whose facts list every operation of `Op` — for a
+ * union of variants, **union semantics within the shared APIs**: a code of an
+ * API all of them serve, listed with `Op` by any of them. {@link AdtCodeWith}
+ * is the intersection.
+ */
 export type AdtTypeCodeWith<V extends AdtVariant, Op extends AdtOperation> = {
     [A in AdtApi<V>]: CodesWith<TableOf<V>[A], Op>;
 }[AdtApi<V>];
-/** Every kind of any table — the tools' one vocabulary for objects. */
+/**
+ * Every kind of any table — the tools' one vocabulary for objects. A union
+ * over all variants by design.
+ */
 export type AdtObjectKind = {
     [V in AdtVariant]: {
         [A in AdtApi<V>]: TableOf<V>[A] extends {
@@ -1075,7 +1109,11 @@ export type AdtObjectKind = {
         } ? K : never;
     }[AdtApi<V>];
 }[AdtVariant];
-/** The codes, of any table, whose API reads a source there (`source`). */
+/**
+ * The codes, of any table, whose API reads a source there (`source`) — a union
+ * over all variants by design. A variant's own, intersected for a union of
+ * variants, is `AdtCodeWith<V, 'source'>`.
+ */
 export type AdtSourceTypeCode = {
     [V in AdtVariant]: AdtTypeCodeWith<V, 'source'>;
 }[AdtVariant];
@@ -1088,5 +1126,62 @@ export type AdtParentedTypeCode = {
         [A in AdtApi<V>]: ParentedCodesOf<TableOf<V>[A]>;
     }[AdtApi<V>];
 }[AdtVariant];
+type CodesOfTable<T> = {
+    [A in keyof T]: CodesOf<T[A]>;
+}[keyof T];
+type CodesWithInTable<T, Op extends AdtOperation> = {
+    [A in keyof T]: CodesWith<T[A], Op>;
+}[keyof T];
+/** The variants, among `Tables`' keys, whose table lists code `C`. */
+type VariantsListingIn<Tables, C> = {
+    [W in keyof Tables]: C extends CodesOfTable<Tables[W]> ? W : never;
+}[keyof Tables];
+/** The variants, among `Tables`' keys, whose table lists `Op` for code `C`. */
+type VariantsWhereCodeHasIn<Tables, C, Op extends AdtOperation> = {
+    [W in keyof Tables]: C extends CodesWithInTable<Tables[W], Op> ? W : never;
+}[keyof Tables];
+/**
+ * The variants, among `Tables`' keys, whose table serves API `A`. Each key is
+ * read on its own table, so nothing distributes over a union of tables.
+ */
+export type AdtServingVariantsIn<Tables, A extends AdtApiName> = {
+    [W in keyof Tables]: A extends keyof Tables[W] ? W : never;
+}[keyof Tables];
+/**
+ * The variants, among `Tables`' keys, one code of whose API `A` lists every
+ * operation of `Op` (or, for a codeless API, whose entry does).
+ */
+export type AdtPerformingVariantsIn<Tables, A extends AdtApiName, Op extends AdtOperation> = {
+    [W in keyof Tables]: [A] extends [AdtApiWithIn<Tables[W], Op>] ? W : never;
+}[keyof Tables];
+/** The codes any table of `V` lists — the candidates, each table read alone. */
+type CandidateCodes<Tables, V extends keyof Tables> = {
+    [W in V]: CodesOfTable<Tables[W]>;
+}[V];
+/** The codes any table of `V` lists `Op` for, each table read alone. */
+type CandidateCodesWith<Tables, V extends keyof Tables, Op extends AdtOperation> = {
+    [W in V]: CodesWithInTable<Tables[W], Op>;
+}[V];
+/** The codes every table of `V` among `Tables` lists: the intersection. */
+export type AdtCodeOfIn<Tables, V extends keyof Tables> = {
+    [C in CandidateCodes<Tables, V>]: [V] extends [VariantsListingIn<Tables, C>] ? C : never;
+}[CandidateCodes<Tables, V>];
+/** The codes for which every table of `V` among `Tables` lists `Op`. */
+export type AdtCodeWithIn<Tables, V extends keyof Tables, Op extends AdtOperation> = {
+    [C in CandidateCodesWith<Tables, V, Op>]: [V] extends [
+        VariantsWhereCodeHasIn<Tables, C, Op>
+    ] ? C : never;
+}[CandidateCodesWith<Tables, V, Op>];
+/**
+ * The codes every variant of `V` lists — for the default modern variant, the
+ * codes both newer tables list. The intersecting counterpart of
+ * {@link AdtTypeCodeOf}.
+ */
+export type AdtCodeOf<V extends AdtVariant> = AdtCodeOfIn<IAdtTypeTables, V>;
+/**
+ * The codes for which every variant of `V` lists every operation of `Op` —
+ * the intersecting counterpart of {@link AdtTypeCodeWith}.
+ */
+export type AdtCodeWith<V extends AdtVariant, Op extends AdtOperation> = AdtCodeWithIn<IAdtTypeTables, V, Op>;
 export {};
 //# sourceMappingURL=AdtTypeTables.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AdtTypeTables.d.ts","sourceRoot":"","sources":["../../src/adt/AdtTypeTables.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"AdtTypeTables.d.ts","sourceRoot":"","sources":["../../src/adt/AdtTypeTables.ts"],"names":[],"mappings":"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"}

package/dist/adt/AdtTypeTables.js

@@ -23,9 +23,9 @@ exports.ADT_TYPES_BASIS_740 = exports.ADT_TYPES_CLOUD = exports.ADT_TYPES_ONPREM
 /**
  * What the library serves on **S/4HANA 2025 on-premise**, API by API.
  *
- * Identical in operations to {@link ADT_TYPES_CLOUD}: the library has no
- * on-premise or cloud branch. The two differ where the releases do —
- * `SRVD/SRV` takes 40 characters here and 30 on ABAP cloud.
+ * The library has no on-premise or cloud branch; the two tables differ where
+ * the releases do — `SRVD/SRV` takes 40 characters here and 30 on ABAP
+ * cloud, and a program or an include is created and changed only here.
  */
 exports.ADT_TYPES_ONPREM = {
     class: {
@@ -41,6 +41,7 @@ exports.ADT_TYPES_ONPREM = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -77,6 +78,7 @@ exports.ADT_TYPES_ONPREM = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -104,6 +106,7 @@ exports.ADT_TYPES_ONPREM = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -195,6 +198,7 @@ exports.ADT_TYPES_ONPREM = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -276,6 +280,7 @@ exports.ADT_TYPES_ONPREM = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -956,7 +961,9 @@ exports.ADT_TYPES_ONPREM = {
 /**
  * What the library serves on **ABAP cloud** (measured on the BTP trial), API by
  * API. The same operations as {@link ADT_TYPES_ONPREM}, and this release's
- * name lengths.
+ * name lengths, but for a program (`PROG/P`) and an include (`PROG/I`): the
+ * cloud refuses to create either (`403`, S_DEVELOP), so they list only what a
+ * delivered one answers — nothing that changes an object.
  */
 exports.ADT_TYPES_CLOUD = {
     class: {
@@ -972,6 +979,7 @@ exports.ADT_TYPES_CLOUD = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -1008,6 +1016,7 @@ exports.ADT_TYPES_CLOUD = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -1030,19 +1039,11 @@ exports.ADT_TYPES_CLOUD = {
                 parent: null,
                 nameMaxLength: 40,
                 operations: [
-                    'create',
                     'read',
                     'source',
                     'readMetadata',
-                    'update',
-                    'lock',
-                    'unlock',
-                    'activate',
                     'check',
-                    'validate',
                     'versions',
-                    'deletionCheck',
-                    'delete',
                     'transport',
                     'readEnhancementElements',
                     'readEnhancementOptions',
@@ -1065,17 +1066,9 @@ exports.ADT_TYPES_CLOUD = {
                 parent: null,
                 nameMaxLength: 40,
                 operations: [
-                    'create',
                     'read',
                     'source',
                     'readMetadata',
-                    'update',
-                    'lock',
-                    'unlock',
-                    'activate',
-                    'validate',
-                    'deletionCheck',
-                    'delete',
                     'readEnhancementElements',
                     'readEnhancementOptions',
                 ],
@@ -1126,6 +1119,7 @@ exports.ADT_TYPES_CLOUD = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',
@@ -1207,6 +1201,7 @@ exports.ADT_TYPES_CLOUD = {
                     'source',
                     'readMetadata',
                     'update',
+                    'updateMetadata',
                     'lock',
                     'unlock',
                     'activate',