@abapify/adt-contracts 0.3.6 → 0.4.1

package/dist/base-BsgeOhzu.mjs

@@ -0,0 +1,2468 @@
+import { acoverageResult, acoverageStatements, adtcore, atc, atcRun, atcworklist, atomFeed, aunitResult, aunitRun, badi, blueSource, checkrun, classes, configuration, configurations as configurations$1, dataelementWrapper, dclSource, ddlSource, discovery, domain, fmodules, groups as groups$1, http as http$2, includes, interfaces, packagesV1, programs, servicebinding, srvdSource, systeminformation, tabletype, transportUseraction, transportfind, transportmanagment, transportmanagmentCreate, transportmanagmentSingle } from "./schemas.mjs";
+import { createClient, http, http as http$1 } from "@abapify/speci/rest";
+
+//#region src/helpers/text-schema.ts
+/**
+* Serializable<string> for text/plain request/response bodies.
+*
+* `parse` coerces the raw response to string; `build` returns the string as-is.
+* The `_infer` marker is the key piece — speci checks for it with `'_infer' in value`
+* to decide whether the descriptor carries a body schema.
+*/
+const textPlain = {
+	parse: (x) => String(x),
+	build: (x) => x,
+	_infer: void 0
+};
+
+//#endregion
+//#region src/helpers/crud.ts
+/**
+* CRUD Contract Helper
+*
+* Generates full CRUD contracts for ADT repository objects following the
+* standard SAP ADT URL template pattern:
+*
+*   {basePath}/{object_name}{?corrNr,lockHandle,version,accessMode,_action}
+*
+* @example
+* ```ts
+* import { crud } from '../helpers/crud';
+* import { classes } from '../schemas';
+*
+* export const classesContract = crud({
+*   basePath: '/sap/bc/adt/oo/classes',
+*   schema: classes,
+*   contentType: 'application/vnd.sap.adt.oo.classes.v4+xml',
+* });
+*
+* // Usage:
+* // classesContract.get('zcl_my_class')
+* // classesContract.post({ corrNr: 'DEVK900001' })
+* // classesContract.put('zcl_my_class', { lockHandle: '...' })
+* // classesContract.delete('zcl_my_class')
+* ```
+*/
+/**
+* Create source operations for a given source type
+*/
+function createSourceOperations(basePath, sourceType, nameTransform) {
+	return {
+		get: (name) => http.get(`${basePath}/${nameTransform(name)}/source/${sourceType}`, {
+			responses: { 200: void 0 },
+			headers: { Accept: "text/plain" }
+		}),
+		put: (name, options) => http.put(`${basePath}/${nameTransform(name)}/source/${sourceType}`, {
+			body: textPlain,
+			responses: { 200: void 0 },
+			headers: {
+				Accept: "text/plain",
+				"Content-Type": "text/plain"
+			},
+			query: {
+				...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+				...options?.corrNr ? { corrNr: options.corrNr } : {}
+			}
+		})
+	};
+}
+/**
+* Create include operations for a given include type
+*/
+function createIncludeOperations(basePath, includeType, nameTransform) {
+	return {
+		get: (name) => http.get(`${basePath}/${nameTransform(name)}/includes/${includeType}`, {
+			responses: { 200: void 0 },
+			headers: { Accept: "text/plain" }
+		}),
+		put: (name, options) => http.put(`${basePath}/${nameTransform(name)}/includes/${includeType}`, {
+			body: textPlain,
+			responses: { 200: void 0 },
+			headers: {
+				Accept: "text/plain",
+				"Content-Type": "text/plain"
+			},
+			query: {
+				...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+				...options?.corrNr ? { corrNr: options.corrNr } : {}
+			}
+		})
+	};
+}
+/**
+* Create a full CRUD contract for an ADT repository object
+*
+* Follows the standard SAP ADT URL template pattern:
+*   {basePath}/{object_name}{?corrNr,lockHandle,version,accessMode,_action}
+*
+* @example Basic CRUD
+* ```ts
+* const packagesContract = crud({
+*   basePath: '/sap/bc/adt/packages',
+*   schema: packages,
+*   contentType: 'application/vnd.sap.adt.packages.v1+xml',
+* });
+* ```
+*
+* @example With source code support
+* ```ts
+* const interfacesContract = crud({
+*   basePath: '/sap/bc/adt/oo/interfaces',
+*   schema: interfaces,
+*   contentType: 'application/vnd.sap.adt.oo.interfaces.v5+xml',
+*   sources: ['main'],
+* });
+* // interfacesContract.source.main.get('zif_my_interface')
+* ```
+*
+* @example With includes support (classes)
+* ```ts
+* const classesContract = crud({
+*   basePath: '/sap/bc/adt/oo/classes',
+*   schema: classes,
+*   contentType: 'application/vnd.sap.adt.oo.classes.v4+xml',
+*   sources: ['main'],
+*   includes: ['definitions', 'implementations', 'macros'],
+* });
+* // classesContract.source.main.get('zcl_my_class')
+* // classesContract.includes.definitions.get('zcl_my_class')
+* // classesContract.includes.get('zcl_my_class', 'implementations')
+* ```
+*/
+function crud(options) {
+	const { basePath, schema, contentType, accept = contentType, nameTransform = (n) => n.toLowerCase(), sources, includes } = options;
+	return {
+		bodySchema: schema,
+		get: (name, queryOptions) => http.get(`${basePath}/${nameTransform(name)}`, {
+			responses: { 200: schema },
+			headers: { Accept: accept },
+			query: queryOptions?.version ? { version: queryOptions.version } : void 0
+		}),
+		post: (queryOptions) => http.post(basePath, {
+			body: schema,
+			responses: { 200: schema },
+			headers: {
+				Accept: accept,
+				"Content-Type": contentType
+			},
+			query: queryOptions?.corrNr ? { corrNr: queryOptions.corrNr } : void 0
+		}),
+		put: (name, queryOptions) => http.put(`${basePath}/${nameTransform(name)}`, {
+			body: schema,
+			responses: { 200: schema },
+			headers: {
+				Accept: accept,
+				"Content-Type": contentType
+			},
+			query: {
+				...queryOptions?.corrNr ? { corrNr: queryOptions.corrNr } : {},
+				...queryOptions?.lockHandle ? { lockHandle: queryOptions.lockHandle } : {}
+			}
+		}),
+		delete: (name, queryOptions) => http.delete(`${basePath}/${nameTransform(name)}`, {
+			responses: { 204: void 0 },
+			query: {
+				...queryOptions?.corrNr ? { corrNr: queryOptions.corrNr } : {},
+				...queryOptions?.lockHandle ? { lockHandle: queryOptions.lockHandle } : {}
+			}
+		}),
+		lock: (name, lockOptions) => http.post(`${basePath}/${nameTransform(name)}`, {
+			responses: { 200: void 0 },
+			headers: {
+				"X-sap-adt-sessiontype": "stateful",
+				"x-sap-security-session": "use",
+				Accept: "application/*,application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.lock.result"
+			},
+			query: {
+				_action: "LOCK",
+				accessMode: lockOptions?.accessMode ?? "MODIFY",
+				...lockOptions?.corrNr ? { corrNr: lockOptions.corrNr } : {}
+			}
+		}),
+		unlock: (name, unlockOptions) => http.post(`${basePath}/${nameTransform(name)}`, {
+			responses: { 200: void 0 },
+			headers: {
+				"X-sap-adt-sessiontype": "stateful",
+				"x-sap-security-session": "use"
+			},
+			query: {
+				_action: "UNLOCK",
+				accessMode: "MODIFY",
+				lockHandle: unlockOptions.lockHandle
+			}
+		}),
+		objectstructure: (name, structureOptions) => http.get(`${basePath}/${nameTransform(name)}/objectstructure`, {
+			responses: { 200: void 0 },
+			query: {
+				...structureOptions?.version ? { version: structureOptions.version } : {},
+				...structureOptions?.withShortDescriptions !== void 0 ? { withShortDescriptions: String(structureOptions.withShortDescriptions) } : {}
+			}
+		}),
+		...sources ? { source: Object.fromEntries(sources.map((sourceType) => [sourceType, createSourceOperations(basePath, sourceType, nameTransform)])) } : {},
+		...includes ? { includes: {
+			get: (name, includeType) => http.get(`${basePath}/${nameTransform(name)}/includes/${includeType}`, {
+				responses: { 200: void 0 },
+				headers: { Accept: "text/plain" }
+			}),
+			put: (name, includeType, options) => http.put(`${basePath}/${nameTransform(name)}/includes/${includeType}`, {
+				body: textPlain,
+				responses: { 200: void 0 },
+				headers: {
+					Accept: "text/plain",
+					"Content-Type": "text/plain"
+				},
+				query: {
+					...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+					...options?.corrNr ? { corrNr: options.corrNr } : {}
+				}
+			}),
+			...Object.fromEntries(includes.map((includeType) => [includeType, createIncludeOperations(basePath, includeType, nameTransform)]))
+		} } : {}
+	};
+}
+/**
+* Shorthand alias for crud()
+*
+* @example
+* ```ts
+* export const classesContract = repo('/sap/bc/adt/oo/classes', classes, 'application/vnd.sap.adt.oo.classes.v4+xml');
+* ```
+*/
+function repo(basePath, schema, contentType, nameTransform, accept) {
+	return crud({
+		basePath,
+		schema,
+		contentType,
+		accept,
+		nameTransform
+	});
+}
+
+//#endregion
+//#region src/adt/cts/transportrequests/valuehelp/attribute.ts
+/**
+* /sap/bc/adt/cts/transportrequests/valuehelp/attribute
+*/
+const attribute = { get: (params) => http.get("/sap/bc/adt/cts/transportrequests/valuehelp/attribute", {
+	query: params,
+	responses: { 200: void 0 },
+	headers: { Accept: "application/xml" }
+}) };
+
+//#endregion
+//#region src/adt/cts/transportrequests/valuehelp/target.ts
+/**
+* /sap/bc/adt/cts/transportrequests/valuehelp/target
+*/
+const target = { get: (params) => http.get("/sap/bc/adt/cts/transportrequests/valuehelp/target", {
+	query: params,
+	responses: { 200: void 0 },
+	headers: { Accept: "application/xml" }
+}) };
+
+//#endregion
+//#region src/adt/cts/transportrequests/valuehelp/ctsproject.ts
+/**
+* /sap/bc/adt/cts/transportrequests/valuehelp/ctsproject
+*/
+const ctsproject = { get: (params) => http.get("/sap/bc/adt/cts/transportrequests/valuehelp/ctsproject", {
+	query: params,
+	responses: { 200: void 0 },
+	headers: { Accept: "application/xml" }
+}) };
+
+//#endregion
+//#region src/adt/cts/transportrequests/valuehelp/object.ts
+/**
+* /sap/bc/adt/cts/transportrequests/valuehelp/object
+*/
+const object = { get: (field, params) => http.get(`/sap/bc/adt/cts/transportrequests/valuehelp/object/${field}`, {
+	query: params,
+	responses: { 200: void 0 },
+	headers: { Accept: "application/xml" }
+}) };
+
+//#endregion
+//#region src/adt/cts/transportrequests/valuehelp/index.ts
+/**
+* /sap/bc/adt/cts/transportrequests/valuehelp
+*/
+const valuehelp = {
+	attribute,
+	target,
+	ctsproject,
+	object
+};
+
+//#endregion
+//#region src/adt/cts/transportrequests/reference.ts
+/**
+* /sap/bc/adt/cts/transportrequests/reference
+* @source transportmanagementref.json
+*/
+const reference = { get: () => http.get("/sap/bc/adt/cts/transportrequests/reference", {
+	responses: { 200: void 0 },
+	headers: { Accept: "application/xml" }
+}) };
+
+//#endregion
+//#region src/adt/cts/transportrequests/searchconfiguration/configurations.ts
+/**
+* /sap/bc/adt/cts/transportrequests/searchconfiguration/configurations
+* @schema configurations.xsd, configuration.xsd
+*/
+const configurations = contract({
+	get: () => http$1.get("/sap/bc/adt/cts/transportrequests/searchconfiguration/configurations", {
+		responses: { 200: configurations$1 },
+		headers: { Accept: "application/vnd.sap.adt.configurations.v1+xml" }
+	}),
+	getById: (_configId) => http$1.get("/sap/bc/adt/cts/transportrequests/searchconfiguration/configurations/${configId}", {
+		responses: { 200: configuration },
+		headers: { Accept: "application/vnd.sap.adt.configuration.v1+xml" }
+	}),
+	put: (_configId) => http$1.put("/sap/bc/adt/cts/transportrequests/searchconfiguration/configurations/${configId}", {
+		responses: { 200: configuration },
+		headers: {
+			"Content-Type": "application/vnd.sap.adt.configuration.v1+xml",
+			Accept: "application/vnd.sap.adt.configuration.v1+xml"
+		},
+		body: configuration
+	})
+});
+
+//#endregion
+//#region src/adt/cts/transportrequests/searchconfiguration/metadata.ts
+/**
+* /sap/bc/adt/cts/transportrequests/searchconfiguration/metadata
+* @schema configuration.xsd
+*/
+const metadata = contract({ get: () => http$1.get("/sap/bc/adt/cts/transportrequests/searchconfiguration/metadata", {
+	responses: { 200: configuration },
+	headers: { Accept: "application/vnd.sap.adt.configuration.metadata.v1+xml" }
+}) });
+
+//#endregion
+//#region src/adt/cts/transportrequests/searchconfiguration/index.ts
+/**
+* /sap/bc/adt/cts/transportrequests/searchconfiguration
+*/
+const searchconfiguration = {
+	configurations,
+	metadata
+};
+
+//#endregion
+//#region src/adt/cts/transportrequests/useraction.ts
+/**
+* /sap/bc/adt/cts/transportrequests - user-action body endpoints
+*
+* SAP ADT uses POST with a `<tm:root tm:useraction="...">` XML body for
+* release / changeowner / newrequest actions. This file exposes typed
+* endpoints that wrap those three operations.
+*
+*   release       → POST /{trkorr}
+*   changeowner   → POST /{trkorr}    (requires tm:targetuser, optional tm:recursive)
+*   newrequest    → POST /            (creates a new transport request)
+*
+* All three share the same namespace and content-type but differ in
+* request shape and URL, so we expose them as separate methods with
+* strongly-typed options while sharing a single schema.
+*/
+const CONTENT_TYPE = "application/vnd.sap.adt.transportorganizer.v1+xml";
+const useraction = {
+	release: (trkorr) => http$1.post(`/sap/bc/adt/cts/transportrequests/${trkorr}`, {
+		body: transportUseraction,
+		responses: { 200: transportmanagmentSingle },
+		headers: {
+			Accept: CONTENT_TYPE,
+			"Content-Type": CONTENT_TYPE
+		}
+	}),
+	reassign: (trkorr, _options) => http$1.post(`/sap/bc/adt/cts/transportrequests/${trkorr}`, {
+		body: transportUseraction,
+		responses: { 200: transportmanagmentSingle },
+		headers: {
+			Accept: CONTENT_TYPE,
+			"Content-Type": CONTENT_TYPE
+		}
+	}),
+	create: (_options) => http$1.post("/sap/bc/adt/cts/transportrequests", {
+		body: transportUseraction,
+		responses: { 200: transportmanagmentSingle },
+		headers: {
+			Accept: CONTENT_TYPE,
+			"Content-Type": CONTENT_TYPE
+		}
+	})
+};
+
+//#endregion
+//#region src/adt/cts/transportrequests/index.ts
+/**
+* /sap/bc/adt/cts/transportrequests
+* @source transportmanagement.json
+*/
+/** Re-export schema for consumers that need direct parsing */
+const transportrequests = {
+	list: (params) => http$1.get("/sap/bc/adt/cts/transportrequests", {
+		query: params,
+		responses: { 200: transportmanagment },
+		headers: { Accept: "*/*" }
+	}),
+	get: (trkorr) => http$1.get(`/sap/bc/adt/cts/transportrequests/${trkorr}`, {
+		responses: { 200: transportmanagmentSingle },
+		headers: { Accept: "application/vnd.sap.adt.transportorganizer.v1+xml" }
+	}),
+	create: () => http$1.post("/sap/bc/adt/cts/transportrequests", {
+		body: transportmanagmentCreate,
+		responses: { 200: transportmanagmentSingle },
+		headers: {
+			Accept: "application/vnd.sap.adt.transportorganizer.v1+xml",
+			"Content-Type": "application/xml"
+		}
+	}),
+	post: (trkorr) => http$1.post(`/sap/bc/adt/cts/transportrequests/${trkorr}`, {
+		body: transportmanagment,
+		responses: { 200: transportmanagment },
+		headers: {
+			Accept: "application/vnd.sap.adt.transportorganizer.v1+xml",
+			"Content-Type": "application/xml"
+		}
+	}),
+	put: (trkorr) => http$1.put(`/sap/bc/adt/cts/transportrequests/${trkorr}`, {
+		body: transportmanagment,
+		responses: { 200: transportmanagment },
+		headers: {
+			Accept: "application/vnd.sap.adt.transportorganizer.v1+xml",
+			"Content-Type": "application/xml"
+		}
+	}),
+	delete: (trkorr) => http$1.delete(`/sap/bc/adt/cts/transportrequests/${trkorr}`, { responses: { 204: void 0 } }),
+	reference,
+	valuehelp,
+	searchconfiguration,
+	useraction
+};
+
+//#endregion
+//#region src/adt/cts/transports.ts
+/**
+* /sap/bc/adt/cts/transports/**
+* ADT CTS Transports Contract
+*
+* GET with _action=FIND - Search transports (undocumented but works)
+*
+* Uses manual ts-xsd schema from adt-schemas for proper XML parsing.
+*/
+/**
+* Transport function codes (TRFUNCTION field)
+*/
+const TransportFunction = {
+	WORKBENCH: "K",
+	CUSTOMIZING: "W",
+	TRANSPORT_OF_COPIES: "T",
+	DEVELOPMENT_CORRECTION: "S",
+	REPAIR: "R",
+	UNCLASSIFIED: "X",
+	CUSTOMIZING_TASK: "Q",
+	ALL: "*"
+};
+/**
+* Transport status codes (TRSTATUS field) - for response parsing
+*/
+const TransportStatus = {
+	MODIFIABLE: "D",
+	RELEASE_STARTED: "O",
+	RELEASE_IN_PREPARATION: "P",
+	RELEASED: "R",
+	LOCKED: "L"
+};
+/**
+* Normalize response to always return array of headers
+* Works with the parsed transportfind schema response
+*/
+function normalizeTransportFindResponse(response) {
+	const headers = response?.values?.DATA?.CTS_REQ_HEADER;
+	if (!headers) return [];
+	return Array.isArray(headers) ? headers : [headers];
+}
+const transports = { find: (params) => http.get("/sap/bc/adt/cts/transports", {
+	query: params,
+	responses: { 200: transportfind },
+	headers: { Accept: "*/*" }
+}) };
+
+//#endregion
+//#region src/adt/cts/transportchecks.ts
+/**
+* /sap/bc/adt/cts/transportchecks
+* @source transportchecks.json
+*/
+const transportchecks = { get: () => http.get("/sap/bc/adt/cts/transportchecks", {
+	responses: { 200: void 0 },
+	headers: { Accept: "application/xml" }
+}) };
+
+//#endregion
+//#region src/adt/cts/index.ts
+/**
+* ADT CTS (Change and Transport System) Contracts
+*
+* Structure mirrors URL tree:
+* - /sap/bc/adt/cts/transportrequests → cts.transportrequests
+* - /sap/bc/adt/cts/transports → cts.transports
+* - /sap/bc/adt/cts/transportchecks → cts.transportchecks
+*
+* Based on collections in: e2e/adt-codegen/generated/collections/sap/bc/adt/cts/
+*/
+const ctsContract = {
+	transportrequests,
+	transports,
+	transportchecks
+};
+
+//#endregion
+//#region src/generated/adt/sap/bc/adt/atc/worklists.ts
+/**
+* ATC worklist
+*
+* Endpoint: /sap/bc/adt/atc/worklists
+* Category: atcworklists
+*
+* @generated - DO NOT EDIT MANUALLY
+*/
+const worklistsContract = contract({
+	get: (worklistId, params) => http$1.get(`/sap/bc/adt/atc/worklists/${worklistId}`, {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "*/*" }
+	}),
+	objectset: (worklistId, objectSetName, params) => http$1.get(`/sap/bc/adt/atc/worklists/${worklistId}/${objectSetName}`, {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "*/*" }
+	})
+});
+
+//#endregion
+//#region src/generated/adt/sap/bc/adt/atc/results.ts
+/**
+* ATC results
+*
+* Endpoint: /sap/bc/adt/atc/results
+* Category: atcresults
+*
+* @generated - DO NOT EDIT MANUALLY
+*/
+const resultsContract = contract({
+	active: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	activeforsysid: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	user: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	central: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	centralforsysid: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	displayid: (displayId, params) => http$1.get(`/sap/bc/adt/atc/results/${displayId}`, {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	})
+});
+
+//#endregion
+//#region src/adt/atc/index.ts
+/**
+* ADT ATC (ABAP Test Cockpit) Contracts
+*
+* Combines generated contracts with manually-defined endpoints not in discovery.
+*
+* Structure mirrors URL tree:
+* - /sap/bc/adt/atc/customizing → atc.customizing (manual - not in discovery)
+* - /sap/bc/adt/atc/runs → atc.runs (manual - POST with body)
+* - /sap/bc/adt/atc/results → atc.results (generated)
+* - /sap/bc/adt/atc/worklists → atc.worklists (generated + manual create)
+*/
+/**
+* /sap/bc/adt/atc/customizing
+* Get ATC customizing settings (check variants, exemption reasons, etc.)
+*
+* NOTE: Not in SAP discovery - manually defined
+*/
+const customizing = contract({ get: () => http$1.get("/sap/bc/adt/atc/customizing", {
+	responses: { 200: atc },
+	headers: { Accept: "application/xml" }
+}) });
+/**
+* /sap/bc/adt/atc/runs
+*
+* NOTE: POST endpoint with body - not in SAP discovery
+* @source atcruns.json
+*/
+const runs = contract({ post: (params) => http$1.post("/sap/bc/adt/atc/runs", {
+	query: params,
+	body: atcRun,
+	responses: { 200: atcworklist },
+	headers: {
+		Accept: "application/xml",
+		"Content-Type": "application/xml"
+	}
+}) });
+/**
+* /sap/bc/adt/atc/worklists - Extended
+*
+* Adds POST (create) endpoint not in generated contract
+*/
+const worklistsExtended = contract({ create: (params) => http$1.post("/sap/bc/adt/atc/worklists", {
+	query: params,
+	responses: { 200: atcworklist },
+	headers: { Accept: "*/*" }
+}) });
+/**
+* Combined ATC contract
+*
+* Uses generated contracts where available, adds manual endpoints for:
+* - customizing (not in discovery)
+* - runs POST (not in discovery)
+* - worklists.create (not in discovery)
+*/
+const atcContract = {
+	customizing,
+	runs,
+	results: resultsContract,
+	worklists: {
+		...worklistsContract,
+		...worklistsExtended
+	}
+};
+
+//#endregion
+//#region src/adt/aunit/coverage-link.ts
+/**
+* Coverage link helper for AUnit responses.
+*
+* When coverage is enabled on an ABAP Unit run, the aunit:runResult
+* contains an atom:link with `rel` referring to the coverage measurement.
+* Example:
+*
+*   <atom:link href="/sap/bc/adt/runtime/traces/coverage/measurements/6D664D9B46CB1FE1859107ADE8729541"
+*              rel="http://www.sap.com/adt/relations/runtime/traces/coverage/measurements"/>
+*
+* The measurement ID is the hex segment after /measurements/.
+*/
+const COVERAGE_MEASUREMENT_HREF_RE = /\/sap\/bc\/adt\/runtime\/traces\/coverage\/measurements\/([A-Fa-f0-9]+)/;
+/**
+* Walk the given node (and, shallowly, its top-level children) searching
+* for an atom:link whose href points to a coverage measurement. Returns
+* the measurement ID (hex string) if found, otherwise undefined.
+*/
+function extractCoverageMeasurementId(result) {
+	if (!result || typeof result !== "object") return void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [result];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (!current || typeof current !== "object" || seen.has(current)) continue;
+		seen.add(current);
+		const obj = current;
+		const links = obj.link;
+		let linkList;
+		if (Array.isArray(links)) linkList = links;
+		else if (links && typeof links === "object") linkList = [links];
+		else linkList = [];
+		for (const link of linkList) {
+			const href = link && typeof link === "object" ? link.href ?? void 0 : void 0;
+			if (!href) continue;
+			const match = COVERAGE_MEASUREMENT_HREF_RE.exec(href);
+			if (match) return match[1];
+		}
+		for (const value of Object.values(obj)) if (Array.isArray(value)) for (const v of value) queue.push(v);
+		else if (value && typeof value === "object") queue.push(value);
+	}
+}
+
+//#endregion
+//#region src/adt/aunit/index.ts
+/**
+* ADT AUnit (ABAP Unit) Contracts
+*
+* Manually-defined endpoints for ABAP Unit test runs.
+*
+* Structure mirrors URL tree:
+* - /sap/bc/adt/abapunit/testruns → aunit.testruns (POST with body)
+*/
+/**
+* /sap/bc/adt/abapunit/testruns
+*
+* Run ABAP Unit tests on objects specified in the request body.
+*
+* NOTE: Not in SAP discovery - manually defined
+*/
+const testruns = contract({ post: () => http$1.post("/sap/bc/adt/abapunit/testruns", {
+	body: aunitRun,
+	responses: { 200: aunitResult },
+	headers: {
+		Accept: "application/vnd.sap.adt.abapunit.testruns.result.v2+xml",
+		"Content-Type": "application/vnd.sap.adt.abapunit.testruns.config.v4+xml"
+	}
+}) });
+/**
+* Combined AUnit contract
+*/
+const aunitContract = { testruns };
+
+//#endregion
+//#region src/adt/oo/classes.ts
+/**
+* ADT OO Classes Contract
+*
+* Endpoint: /sap/bc/adt/oo/classes
+* Full CRUD operations for ABAP classes including source code management.
+*
+* Uses the crud() helper with sources and includes options for complete
+* class operations including metadata, source code, and class includes.
+*/
+/**
+* /sap/bc/adt/oo/classes
+* Full CRUD operations for ABAP classes
+*
+* Includes:
+* - Basic CRUD: get, post, put, delete
+* - Lock/Unlock: lock, unlock
+* - Object structure: objectstructure
+* - Source code: source.main.get/put
+* - Class includes: includes.{definitions,implementations,macros,testclasses,localtypes}.get/put
+*/
+const classesContract = crud({
+	basePath: "/sap/bc/adt/oo/classes",
+	schema: classes,
+	contentType: "application/vnd.sap.adt.oo.classes.v4+xml",
+	accept: "application/vnd.sap.adt.oo.classes.v4+xml, application/vnd.sap.adt.oo.classes.v3+xml, application/vnd.sap.adt.oo.classes.v2+xml, application/vnd.sap.adt.oo.classes.v1+xml",
+	sources: ["main"],
+	includes: [
+		"definitions",
+		"implementations",
+		"macros",
+		"testclasses",
+		"localtypes"
+	]
+});
+
+//#endregion
+//#region src/adt/oo/interfaces.ts
+/**
+* ADT OO Interfaces Contract
+*
+* Endpoint: /sap/bc/adt/oo/interfaces
+* Full CRUD operations for ABAP interfaces including source code management.
+*
+* Uses the crud() helper with sources option for complete
+* interface operations including metadata and source code.
+*/
+/**
+* /sap/bc/adt/oo/interfaces
+* Full CRUD operations for ABAP interfaces
+*
+* Includes:
+* - Basic CRUD: get, post, put, delete
+* - Lock/Unlock: lock, unlock
+* - Object structure: objectstructure
+* - Source code: source.main.get/put
+*/
+const interfacesContract = crud({
+	basePath: "/sap/bc/adt/oo/interfaces",
+	schema: interfaces,
+	contentType: "application/vnd.sap.adt.oo.interfaces.v5+xml",
+	accept: "application/vnd.sap.adt.oo.interfaces.v5+xml, application/vnd.sap.adt.oo.interfaces.v4+xml, application/vnd.sap.adt.oo.interfaces.v3+xml, application/vnd.sap.adt.oo.interfaces.v2+xml, application/vnd.sap.adt.oo.interfaces+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/oo/classrun.ts
+/**
+* ADT OO Classrun Contract
+*
+* Endpoint: /sap/bc/adt/oo/classrun
+* Execute console application classes implementing IF_OO_ADT_CLASSRUN.
+*/
+/**
+* /sap/bc/adt/oo/classrun
+* Execute console application classes (IF_OO_ADT_CLASSRUN)
+*/
+const classrunContract = contract({ post: (classname, params) => http$1.post(`/sap/bc/adt/oo/classrun/${classname.toLowerCase()}`, {
+	query: params,
+	responses: { 200: void 0 },
+	headers: { Accept: "text/plain" }
+}) });
+
+//#endregion
+//#region src/adt/oo/index.ts
+const ooContract = {
+	classes: classesContract,
+	interfaces: interfacesContract,
+	classrun: classrunContract
+};
+
+//#endregion
+//#region src/adt/discovery/index.ts
+/**
+* ADT Discovery Contract
+*
+* Endpoint: GET /sap/bc/adt/discovery
+* Returns AtomPub service document describing available ADT services.
+*/
+const discoveryContract = { getDiscovery: () => http$1.get("/sap/bc/adt/discovery", {
+	responses: { 200: discovery },
+	headers: { Accept: "application/atomsvc+xml" }
+}) };
+
+//#endregion
+//#region src/adt/packages/index.ts
+/**
+* /sap/bc/adt/packages/**
+* ADT Packages Contract
+*
+* Full CRUD operations for ABAP packages (DEVC).
+*
+* Uses the crud() helper with packagesV1 schema.
+* Package names are case-sensitive (uppercase) — no lowercase transform.
+*
+* @example
+* const pkg = await client.adt.packages.get('ZABAPGIT_EXAMPLES');
+* console.log(pkg.package?.name, pkg.package?.attributes?.packageType);
+*
+* // Create a new package
+* await client.adt.packages.post({ corrNr: 'DEVK900001' });
+*/
+const packagesContract = crud({
+	basePath: "/sap/bc/adt/packages",
+	schema: packagesV1,
+	contentType: "application/vnd.sap.adt.packages.v2+xml",
+	accept: "application/vnd.sap.adt.packages.v2+xml, application/vnd.sap.adt.packages.v1+xml",
+	nameTransform: (n) => encodeURIComponent(n)
+});
+
+//#endregion
+//#region src/adt/core/http/sessions.ts
+/**
+* SAP ADT Sessions Contract
+*
+* HTTP session management and CSRF token initialization.
+* Path: /sap/bc/adt/core/http/sessions
+*/
+const sessionsContract = { getSession: () => http$1.get("/sap/bc/adt/core/http/sessions", {
+	responses: { 200: http$2 },
+	headers: {
+		Accept: "application/vnd.sap.adt.core.http.session.v3+xml",
+		"x-csrf-token": "Fetch",
+		"X-sap-adt-sessiontype": "stateful",
+		"x-sap-security-session": "create"
+	}
+}) };
+
+//#endregion
+//#region src/adt/core/http/systeminformation.ts
+/**
+* SAP ADT System Information Contract
+*
+* Returns system information including SAP release, client, user details.
+* Path: /sap/bc/adt/core/http/systeminformation
+*/
+const systeminformationContract = contract({ getSystemInfo: () => http$1.get("/sap/bc/adt/core/http/systeminformation", {
+	responses: { 200: systeminformation },
+	headers: { Accept: "application/vnd.sap.adt.core.http.systeminformation.v1+json" }
+}) });
+
+//#endregion
+//#region src/adt/core/http/index.ts
+const httpContract = {
+	sessions: sessionsContract,
+	systeminformation: systeminformationContract
+};
+
+//#endregion
+//#region src/adt/core/index.ts
+const coreContract = { http: httpContract };
+
+//#endregion
+//#region src/adt/repository/informationsystem/search.ts
+/**
+* ADT Repository Information System - Search Contract
+*
+* ABAP object search operations.
+* Path: /sap/bc/adt/repository/informationsystem/search
+*/
+const searchContract = { quickSearch: (options) => http$1.get("/sap/bc/adt/repository/informationsystem/search", {
+	query: {
+		operation: "quickSearch",
+		query: options.query,
+		maxResults: options.maxResults || 50,
+		...options.packageName && { packageName: options.packageName },
+		...options.objectType && { objectType: options.objectType }
+	},
+	responses: { 200: adtcore },
+	headers: { Accept: "application/xml" }
+}) };
+
+//#endregion
+//#region src/adt/repository/informationsystem/usagereferences.ts
+/**
+* ADT Repository Information System – Usage References (Where-Used List)
+*
+* The SAP ADT "where-used" service is NOT a simple GET — it is a two-step
+* POST flow discovered via sapcli (`sap/adt/whereused.py`) and confirmed
+* against a real TRL ABAP trial system:
+*
+*   1. POST /sap/bc/adt/repository/informationsystem/usageReferences/scope
+*        + query: uri=<objectUri>&version=active
+*        + Content-Type: application/vnd.sap.adt.repository.usagereferences.scope.request.v1+xml
+*        + Accept:       application/vnd.sap.adt.repository.usagereferences.scope.response.v1+xml
+*        + body: <usagereferences:usageScopeRequest>…</>
+*      → returns a <usagereferences:usageScopeResult> containing the
+*        backend-chosen object types, grade flags and an opaque `payload`
+*        blob (gzip-encoded) that must be echoed back in step 2.
+*
+*   2. POST /sap/bc/adt/repository/informationsystem/usageReferences
+*        + query: uri=<objectUri>&version=active
+*        + Content-Type: application/vnd.sap.adt.repository.usagereferences.request.v1+xml
+*        + Accept:       application/vnd.sap.adt.repository.usagereferences.result.v1+xml
+*        + body: <usagereferences:usageReferenceRequest>
+*                  <usagereferences:affectedObjects/>
+*                  <usagereferences:scope>…copy from step 1 result…</>
+*                </>
+*      → returns a <usagereferences:usageReferenceResult> with all hits.
+*
+* Body/response are passed as plain-text XML because the usagereferences
+* namespace is not yet represented as a typed `adt-schemas` XSD. Callers
+* parse the response themselves (see `find-references` MCP tool).
+*/
+/** Vendor MIME types — must match real SAP verbatim. */
+const SCOPE_REQUEST_MIME = "application/vnd.sap.adt.repository.usagereferences.scope.request.v1+xml";
+const SCOPE_RESPONSE_MIME = "application/vnd.sap.adt.repository.usagereferences.scope.response.v1+xml";
+const SEARCH_REQUEST_MIME = "application/vnd.sap.adt.repository.usagereferences.request.v1+xml";
+const SEARCH_RESPONSE_MIME = "application/vnd.sap.adt.repository.usagereferences.result.v1+xml";
+const USAGEREFS_NAMESPACE = "http://www.sap.com/adt/ris/usageReferences";
+/**
+* Build the XML body for the step-1 scope request. sapcli always sends
+* an empty `<affectedObjects/>`; the backend doesn't inspect its content
+* and populates the result from the URI query parameter.
+*/
+function buildUsageScopeRequestXml() {
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<usagereferences:usageScopeRequest xmlns:usagereferences="${USAGEREFS_NAMESPACE}">\n  <usagereferences:affectedObjects/>
+</usagereferences:usageScopeRequest>`;
+}
+/**
+* Build the XML body for the step-2 search request by wrapping the raw
+* step-1 scope-result XML as a `<usagereferences:scope>` element inside
+* a `<usageReferenceRequest>`.
+*
+* We deliberately do string surgery instead of DOM manipulation because
+* the `payload` element contains base64-gzip content we must not perturb.
+*/
+function buildUsageReferenceRequestXml(scopeResultXml) {
+	let noProlog = scopeResultXml;
+	if (noProlog.startsWith("<?xml")) {
+		const prologEnd = noProlog.indexOf("?>");
+		if (prologEnd !== -1) noProlog = noProlog.slice(prologEnd + 2).replace(/^\s+/, "");
+	}
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<usagereferences:usageReferenceRequest xmlns:usagereferences="${USAGEREFS_NAMESPACE}">\n  <usagereferences:affectedObjects/>
+  ${noProlog.replaceAll(/usagereferences:usageScopeResult/g, "usagereferences:scope")}\n</usagereferences:usageReferenceRequest>`;
+}
+/**
+* Step 1: fetch the default scope for a given object URI.
+*
+* Typed body/response are plain XML strings — the contract provides
+* URL/header/method shape, callers provide the marshalled body via
+* {@link buildUsageScopeRequestXml}.
+*/
+const scope = contract({ post: (params) => http$1.post("/sap/bc/adt/repository/informationsystem/usageReferences/scope", {
+	query: {
+		uri: params.uri,
+		version: params.version ?? "active"
+	},
+	body: textPlain,
+	responses: { 200: void 0 },
+	headers: {
+		Accept: SCOPE_RESPONSE_MIME,
+		"Content-Type": SCOPE_REQUEST_MIME
+	}
+}) });
+/**
+* Step 2: execute the where-used search using the scope blob from step 1.
+*/
+const search = contract({ post: (params) => http$1.post("/sap/bc/adt/repository/informationsystem/usageReferences", {
+	query: {
+		uri: params.uri,
+		version: params.version ?? "active"
+	},
+	body: textPlain,
+	responses: { 200: void 0 },
+	headers: {
+		Accept: SEARCH_RESPONSE_MIME,
+		"Content-Type": SEARCH_REQUEST_MIME
+	}
+}) });
+const usageReferencesContract = {
+	scope,
+	search
+};
+
+//#endregion
+//#region src/adt/repository/informationsystem/index.ts
+const informationsystemContract = {
+	search: searchContract,
+	usageReferences: usageReferencesContract
+};
+
+//#endregion
+//#region src/adt/repository/objectstructure.ts
+/**
+* ADT Repository – generic Object Structure endpoint.
+*
+* Most typed object contracts (`programs`, `classes`, …) already expose
+* their own `.objectstructure()` method via the CRUD helper. This
+* contract handles the *generic* case used by the workbench outline
+* CLI / MCP surfaces: an arbitrary object URI whose type does not have
+* a dedicated typed contract (e.g. DOMA, DTEL, DEVC, BDEF, SRVD, …).
+*
+* ADT endpoint:
+*     GET {objectUri}/objectstructure?version=<active|inactive>
+*
+* The response shape varies wildly between object types, so the
+* returned type is `unknown` — callers handle downstream. Keeping this
+* as a typed contract (instead of a raw `client.fetch()` call) ensures
+* the generic outline path still goes through the contract layer.
+*/
+const objectstructureContract = contract({ get: (params) => http$1.get(`${params.objectUri}/objectstructure`, {
+	query: { ...params.version ? { version: params.version } : {} },
+	responses: { 200: void 0 },
+	headers: { Accept: "application/json" }
+}) });
+
+//#endregion
+//#region src/adt/repository/index.ts
+const repositoryContract = {
+	informationsystem: informationsystemContract,
+	objectstructure: objectstructureContract
+};
+
+//#endregion
+//#region src/adt/programs/programs.ts
+/**
+* ADT Programs Contract
+*
+* Endpoint: /sap/bc/adt/programs/programs
+* Full CRUD operations for ABAP programs including source code management.
+*/
+/**
+* /sap/bc/adt/programs/programs
+* Full CRUD operations for ABAP programs
+*
+* Includes:
+* - Basic CRUD: get, post, put, delete
+* - Lock/Unlock: lock, unlock
+* - Object structure: objectstructure
+* - Source code: source.main.get/put
+*/
+const programsContract = crud({
+	basePath: "/sap/bc/adt/programs/programs",
+	schema: programs,
+	contentType: "application/vnd.sap.adt.programs.programs.v2+xml",
+	accept: "application/vnd.sap.adt.programs.programs.v2+xml, application/vnd.sap.adt.programs.programs.v1+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/programs/includes.ts
+/**
+* ADT Program Includes Contract
+*
+* Endpoint: /sap/bc/adt/programs/includes
+* Full CRUD operations for ABAP program includes (PROG/I) including source
+* code management.
+*
+* Mirrors the shape of `programs.ts` but targets the `/programs/includes`
+* URL space and the `include:abapInclude` XML payload.
+*/
+/**
+* /sap/bc/adt/programs/includes
+* Full CRUD operations for ABAP program includes
+*
+* Includes:
+* - Basic CRUD: get, post, put, delete
+* - Lock/Unlock: lock, unlock
+* - Object structure: objectstructure
+* - Source code: source.main.get/put
+*
+* Content types follow the same "v2 preferred, v1 fallback" pattern SAP
+* uses for includes (observed from real responses; matches sapcli's
+* `sap.adt.programs.Include` OBJTYPE).
+*/
+const includesContract = crud({
+	basePath: "/sap/bc/adt/programs/includes",
+	schema: includes,
+	contentType: "application/vnd.sap.adt.programs.includes.v2+xml",
+	accept: "application/vnd.sap.adt.programs.includes.v2+xml, application/vnd.sap.adt.programs.includes.v1+xml, application/vnd.sap.adt.programs.includes+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/programs/index.ts
+const programsModuleContract = {
+	programs: programsContract,
+	includes: includesContract
+};
+
+//#endregion
+//#region src/adt/functions/groups.ts
+/**
+* ADT Functions Groups Contract
+*
+* Endpoint: /sap/bc/adt/functions/groups
+* Full CRUD operations for ABAP function groups including source code management.
+*/
+/**
+* /sap/bc/adt/functions/groups
+* Full CRUD operations for ABAP function groups
+*
+* Includes:
+* - Basic CRUD: get, post, put, delete
+* - Lock/Unlock: lock, unlock
+* - Object structure: objectstructure
+* - Source code: source.main.get/put
+*/
+const functionGroupsContract = crud({
+	basePath: "/sap/bc/adt/functions/groups",
+	schema: groups$1,
+	contentType: "application/vnd.sap.adt.functions.groups.v3+xml",
+	accept: "application/vnd.sap.adt.functions.groups.v3+xml, application/vnd.sap.adt.functions.groups.v2+xml, application/vnd.sap.adt.functions.groups.v1+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/functions/fmodules.ts
+/**
+* ADT Function Modules Contract
+*
+* Endpoint: /sap/bc/adt/functions/groups/{groupName}/fmodules/{fmName}
+* Sub-resource of function groups.
+*
+* Function modules are child objects of function groups. They have their own
+* lock lifecycle, source code, and metadata but are accessed through the
+* parent group's URL path.
+*/
+const contentType$2 = "application/vnd.sap.adt.functions.fmodules.v3+xml";
+const accept$2 = "application/vnd.sap.adt.functions.fmodules.v3+xml, application/vnd.sap.adt.functions.fmodules.v2+xml, application/vnd.sap.adt.functions.fmodules.v1+xml";
+const basePath$4 = "/sap/bc/adt/functions/groups/${groupName}/fmodules";
+/**
+* /sap/bc/adt/functions/groups/{groupName}/fmodules
+* CRUD operations for function modules within a function group
+*/
+const functionModulesContract = contract({
+	get: (_groupName, _fmName) => http$1.get(basePath$4 + "/${fmName}", {
+		responses: { 200: fmodules },
+		headers: { Accept: accept$2 }
+	}),
+	post: (groupName, queryOptions) => http$1.post(basePath$4, {
+		body: fmodules,
+		responses: { 200: fmodules },
+		headers: {
+			Accept: accept$2,
+			"Content-Type": contentType$2
+		},
+		query: queryOptions?.corrNr ? { corrNr: queryOptions.corrNr } : void 0
+	}),
+	put: (groupName, fmName, options) => http$1.put(basePath$4 + "/${fmName}", {
+		body: fmodules,
+		responses: { 200: fmodules },
+		headers: {
+			Accept: accept$2,
+			"Content-Type": contentType$2
+		},
+		query: {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.corrNr ? { corrNr: options.corrNr } : {}
+		}
+	}),
+	delete: (groupName, fmName, options) => http$1.delete(basePath$4 + "/${fmName}", {
+		responses: { 204: void 0 },
+		query: {
+			...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+			...options?.corrNr ? { corrNr: options.corrNr } : {}
+		}
+	}),
+	lock: (groupName, fmName, options) => http$1.post(basePath$4 + "/${fmName}", {
+		responses: { 200: void 0 },
+		headers: {
+			"X-sap-adt-sessiontype": "stateful",
+			"x-sap-security-session": "use",
+			Accept: "application/*,application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.lock.result"
+		},
+		query: {
+			_action: "LOCK",
+			accessMode: options?.accessMode ?? "MODIFY",
+			...options?.corrNr ? { corrNr: options.corrNr } : {}
+		}
+	}),
+	unlock: (groupName, fmName, options) => http$1.post(basePath$4 + "/${fmName}", {
+		responses: { 200: void 0 },
+		headers: {
+			"X-sap-adt-sessiontype": "stateful",
+			"x-sap-security-session": "use"
+		},
+		query: {
+			_action: "UNLOCK",
+			accessMode: "MODIFY",
+			lockHandle: options.lockHandle
+		}
+	}),
+	source: { main: {
+		get: (_groupName, _fmName) => http$1.get(basePath$4 + "/${fmName}/source/main", {
+			responses: { 200: void 0 },
+			headers: { Accept: "text/plain" }
+		}),
+		put: (groupName, fmName, options) => http$1.put(basePath$4 + "/${fmName}/source/main", {
+			body: textPlain,
+			responses: { 200: void 0 },
+			headers: {
+				Accept: "text/plain",
+				"Content-Type": "text/plain"
+			},
+			query: {
+				...options?.lockHandle ? { lockHandle: options.lockHandle } : {},
+				...options?.corrNr ? { corrNr: options.corrNr } : {}
+			}
+		})
+	} }
+});
+
+//#endregion
+//#region src/adt/functions/index.ts
+const functionsContract = { groups: {
+	...functionGroupsContract,
+	fmodules: functionModulesContract
+} };
+
+//#endregion
+//#region src/adt/ddic/domains.ts
+/**
+* DDIC Domain Contract
+*
+* ADT endpoint: /sap/bc/adt/ddic/domains
+* Content-Type: application/vnd.sap.adt.domains.v2+xml
+* Object type: DOMA/DD (domadd)
+*/
+const domainsContract = crud({
+	basePath: "/sap/bc/adt/ddic/domains",
+	schema: domain,
+	contentType: "application/vnd.sap.adt.domains.v2+xml",
+	accept: "application/vnd.sap.adt.domains.v2+xml, application/vnd.sap.adt.domains.v1+xml"
+});
+
+//#endregion
+//#region src/adt/ddic/dataelements.ts
+/**
+* DDIC Data Element Contract
+*
+* ADT endpoint: /sap/bc/adt/ddic/dataelements
+* Content-Type: application/vnd.sap.adt.dataelements.v2+xml
+* Object type: DTEL/DE (dtelde)
+*/
+const dataelementsContract = crud({
+	basePath: "/sap/bc/adt/ddic/dataelements",
+	schema: dataelementWrapper,
+	contentType: "application/vnd.sap.adt.dataelements.v2+xml",
+	accept: "application/vnd.sap.adt.dataelements.v2+xml, application/vnd.sap.adt.dataelements.v1+xml"
+});
+
+//#endregion
+//#region src/adt/ddic/structures.ts
+/**
+* DDIC Structure Contract
+*
+* ADT endpoint: /sap/bc/adt/ddic/structures
+* Content-Type: application/vnd.sap.adt.structures.v2+xml
+* Object type: TABL/DS (tablds)
+*
+* Uses the custom blueSource wrapper schema because SAP wraps
+* structure responses in a blue:blueSource root element
+* (namespace http://www.sap.com/wbobj/blue) extending AbapSourceMainObject.
+*/
+const basePath$3 = "/sap/bc/adt/ddic/structures";
+const contentType$1 = "application/vnd.sap.adt.structures.v2+xml";
+const accept$1 = "application/vnd.sap.adt.structures.v2+xml, application/vnd.sap.adt.structures.v1+xml";
+const structuresContract = {
+	...crud({
+		basePath: basePath$3,
+		schema: blueSource,
+		contentType: contentType$1,
+		accept: accept$1,
+		sources: ["main"]
+	}),
+	objectstructure: (name, options) => http.get(`${basePath$3}/${name.toLowerCase()}/objectstructure`, {
+		responses: { 200: void 0 },
+		query: options?.version ? { version: options.version } : void 0
+	})
+};
+
+//#endregion
+//#region src/adt/ddic/tables.ts
+/**
+* DDIC Database Table Contract
+*
+* ADT endpoint: /sap/bc/adt/ddic/tables
+* Content-Type: application/vnd.sap.adt.tables.v2+xml
+* Object type: TABL/DT (tabldt)
+*
+* Uses the custom blueSource wrapper schema because SAP wraps
+* TABL responses in a blue:blueSource root element
+* (namespace http://www.sap.com/wbobj/blue) extending AbapSourceMainObject.
+*/
+const basePath$2 = "/sap/bc/adt/ddic/tables";
+const contentType = "application/vnd.sap.adt.tables.v2+xml";
+const accept = "application/vnd.sap.adt.blues.v1+xml, application/vnd.sap.adt.tables.v2+xml";
+const tablesContract = {
+	...crud({
+		basePath: basePath$2,
+		schema: blueSource,
+		contentType,
+		accept,
+		sources: ["main"]
+	}),
+	objectstructure: (name, options) => http.get(`${basePath$2}/${name.toLowerCase()}/objectstructure`, {
+		responses: { 200: void 0 },
+		query: options?.version ? { version: options.version } : void 0
+	})
+};
+
+//#endregion
+//#region src/adt/ddic/tablesettings.ts
+/**
+* DDIC Database Table Settings Contract
+*
+* ADT endpoint: /sap/bc/adt/ddic/db/settings/{name}
+* Content-Type: application/vnd.sap.adt.table.settings.v2+xml
+*
+* Returns the technical DD09L settings for a database table as an XML
+* document. ADK currently consumes this as raw text, so the contract is
+* typed as a plain-text endpoint.
+*/
+const basePath$1 = "/sap/bc/adt/ddic/db/settings";
+const tablesettingsContract = contract({ get: (name) => http$1.get(`${basePath$1}/${name.toLowerCase()}`, {
+	responses: { 200: void 0 },
+	headers: { Accept: "application/vnd.sap.adt.table.settings.v2+xml" }
+}) });
+
+//#endregion
+//#region src/adt/ddic/tabletypes.ts
+/**
+* DDIC Table Type Contract
+*
+* ADT endpoint: /sap/bc/adt/ddic/tabletypes
+* Content-Type: application/vnd.sap.adt.tabletype.v1+xml
+* Object type: TTYP/TT
+*/
+const tabletypesContract = crud({
+	basePath: "/sap/bc/adt/ddic/tabletypes",
+	schema: tabletype,
+	contentType: "application/vnd.sap.adt.tabletype.v1+xml",
+	accept: "application/vnd.sap.adt.tabletype.v1+xml"
+});
+
+//#endregion
+//#region src/adt/ddic/ddl/sources.ts
+/**
+* ADT CDS DDL Source Contract
+*
+* Endpoint: /sap/bc/adt/ddic/ddl/sources
+* Content-Type: application/vnd.sap.adt.ddl.source.v2+xml
+* Object type: DDLS
+*
+* CDS Data Definition sources — the SAP endpoint for CDS views / data
+* definitions. The metadata document lives at `{basePath}/{name}` and
+* the source text at `{basePath}/{name}/source/main`.
+*/
+const ddlSourcesContract = crud({
+	basePath: "/sap/bc/adt/ddic/ddl/sources",
+	schema: ddlSource,
+	contentType: "application/vnd.sap.adt.ddl.source.v2+xml",
+	accept: "application/vnd.sap.adt.ddl.source.v2+xml, application/vnd.sap.adt.ddl.source.v1+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/ddic/ddl/index.ts
+const ddlContract = { sources: ddlSourcesContract };
+
+//#endregion
+//#region src/adt/ddic/dcl/sources.ts
+/**
+* ADT CDS DCL (Access Control) Source Contract
+*
+* Endpoint: /sap/bc/adt/acm/dcl/sources
+*   (Note: the SAP endpoint for DCL sources lives under `acm/dcl`, not
+*   `ddic/dcl`. The contract is exported under `ddic.dcl` for API
+*   parity with the ADK and the sibling DDL contract.)
+* Content-Type: application/vnd.sap.adt.acm.dcl.source.v1+xml
+* Object type: DCLS
+*/
+const dclSourcesContract = crud({
+	basePath: "/sap/bc/adt/acm/dcl/sources",
+	schema: dclSource,
+	contentType: "application/vnd.sap.adt.acm.dcl.source.v1+xml",
+	accept: "application/vnd.sap.adt.acm.dcl.source.v1+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/ddic/dcl/index.ts
+const dclContract = { sources: dclSourcesContract };
+
+//#endregion
+//#region src/adt/ddic/srvd/sources.ts
+/**
+* ADT RAP Service Definition (SRVD) Source Contract
+*
+* Endpoint: /sap/bc/adt/ddic/srvd/sources
+* Content-Type: application/vnd.sap.adt.ddic.srvd.v1+xml
+* Object type: SRVD/SRV
+*
+* RAP Service Definition — CDS-like source that exposes CDS root
+* entities/behaviors via OData. Mirrors the DDL sources shape: metadata
+* document at `{basePath}/{name}`, source text (`.asrvd`) at
+* `{basePath}/{name}/source/main`.
+*
+* Reference: abapGit handler zcl_abapgit_object_srvd.
+*/
+const srvdSourcesContract = crud({
+	basePath: "/sap/bc/adt/ddic/srvd/sources",
+	schema: srvdSource,
+	contentType: "application/vnd.sap.adt.ddic.srvd.v1+xml",
+	accept: "application/vnd.sap.adt.ddic.srvd.v1+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/ddic/srvd/index.ts
+const srvdContract = { sources: srvdSourcesContract };
+
+//#endregion
+//#region src/adt/ddic/index.ts
+const ddicContract = {
+	domains: domainsContract,
+	dataelements: dataelementsContract,
+	structures: structuresContract,
+	tables: tablesContract,
+	tablesettings: tablesettingsContract,
+	tabletypes: tabletypesContract,
+	ddl: ddlContract,
+	dcl: dclContract,
+	srvd: srvdContract
+};
+
+//#endregion
+//#region src/adt/system/users.ts
+/**
+* ADT System Users Contract
+*
+* User lookup and search operations.
+* Path: /sap/bc/adt/system/users
+*/
+const usersContract = {
+	search: (options) => http$1.get("/sap/bc/adt/system/users", {
+		query: {
+			querystring: options.querystring,
+			...options.maxcount !== void 0 && { maxcount: options.maxcount }
+		},
+		responses: { 200: atomFeed },
+		headers: { Accept: "application/atom+xml;type=feed" }
+	}),
+	get: (username) => http$1.get(`/sap/bc/adt/system/users/${encodeURIComponent(username)}`, {
+		responses: { 200: atomFeed },
+		headers: { Accept: "application/atom+xml;type=feed" }
+	})
+};
+
+//#endregion
+//#region src/adt/system/security/pses.ts
+/**
+* ADT System Security / STRUST Contracts
+*
+* Contract surface for SAP STRUST (SSL Personal Security Environment)
+* over the ADT REST API. Paths under `/sap/bc/adt/system/security/pses`.
+*
+* NOTE: sapcli (jfilak/sapcli) drives STRUST via RFC function modules
+* (`sap/rfc/strust.py`), not ADT. The paths below follow the
+* `/sap/bc/adt/system/...` convention used elsewhere in the SAP ADT
+* REST surface (see `system/users`). See the accompanying TODO-synthetic
+* fixtures in `@abapify/adt-fixtures` — replace with real captures when
+* available.
+*/
+/**
+* Inferrable schema wrapper for a PEM (plain-text) request body.
+* Makes `uploadCertificate` accept a `pem: string` argument at the client
+* call-site — speci's `BuildParams` only appends a body parameter when
+* the body is marked Inferrable via the `_infer` tag.
+*/
+const pemBody = { _infer: void 0 };
+const psesContract = {
+	list: () => http$1.get("/sap/bc/adt/system/security/pses", {
+		responses: { 200: atomFeed },
+		headers: { Accept: "application/atom+xml;type=feed" }
+	}),
+	get: (context, applic) => http$1.get(`/sap/bc/adt/system/security/pses/${encodeURIComponent(context)}/${encodeURIComponent(applic)}`, {
+		responses: { 200: atomFeed },
+		headers: { Accept: "application/atom+xml;type=feed" }
+	}),
+	listCertificates: (context, applic) => http$1.get(`/sap/bc/adt/system/security/pses/${encodeURIComponent(context)}/${encodeURIComponent(applic)}/certificates`, {
+		responses: { 200: atomFeed },
+		headers: { Accept: "application/atom+xml;type=feed" }
+	}),
+	getCertificate: (context, applic, id) => http$1.get(`/sap/bc/adt/system/security/pses/${encodeURIComponent(context)}/${encodeURIComponent(applic)}/certificates/${encodeURIComponent(id)}`, {
+		responses: { 200: void 0 },
+		headers: { Accept: "application/x-pem-file" }
+	}),
+	uploadCertificate: (context, applic) => http$1.post(`/sap/bc/adt/system/security/pses/${encodeURIComponent(context)}/${encodeURIComponent(applic)}/certificates`, {
+		body: pemBody,
+		responses: { 200: atomFeed },
+		headers: {
+			Accept: "application/atom+xml;type=feed",
+			"Content-Type": "application/x-pem-file"
+		}
+	}),
+	deleteCertificate: (context, applic, id) => http$1.delete(`/sap/bc/adt/system/security/pses/${encodeURIComponent(context)}/${encodeURIComponent(applic)}/certificates/${encodeURIComponent(id)}`, { responses: { 204: void 0 } })
+};
+
+//#endregion
+//#region src/adt/system/index.ts
+const systemContract = {
+	users: usersContract,
+	security: { pses: psesContract }
+};
+
+//#endregion
+//#region src/adt/checkruns/index.ts
+/**
+* ADT Checkruns Contract
+*
+* Manually-defined endpoint for ABAP syntax check runs.
+*
+* Structure mirrors URL tree:
+* - /sap/bc/adt/checkruns → checkruns.checkObjects (POST with body)
+*
+* NOTE: Not in SAP discovery - manually defined
+*/
+/**
+* /sap/bc/adt/checkruns
+*
+* Run a syntax/check-run on a list of ABAP objects.
+* Request body: checkObjectList (chkrun:CheckObjectList)
+* Response:     checkRunReports (chkrun:CheckReportList)
+*/
+const checkObjects = contract({ post: () => http$1.post("/sap/bc/adt/checkruns", {
+	body: checkrun,
+	responses: { 200: checkrun },
+	headers: {
+		Accept: "application/vnd.sap.adt.checkmessages+xml",
+		"Content-Type": "application/vnd.sap.adt.checkobjects+xml"
+	}
+}) });
+/**
+* Combined Checkruns contract
+*/
+const checkrunsContract = { checkObjects };
+
+//#endregion
+//#region src/adt/activation/index.ts
+/**
+* ADT Activation Contract
+*
+* Manually-defined endpoint for ABAP object activation.
+*
+* Structure mirrors URL tree:
+* - /sap/bc/adt/activation → activation.activate (POST with body)
+*
+* NOTE: Not in SAP discovery - manually defined
+*/
+/**
+* /sap/bc/adt/activation
+*
+* Activate one or more ABAP objects.
+* Request body: adtcore:objectReferences  (AdtcoreSchema variant)
+*/
+const activate = contract({ post: (params) => http$1.post("/sap/bc/adt/activation", {
+	query: params,
+	body: adtcore,
+	responses: { 200: adtcore },
+	headers: {
+		Accept: "application/xml",
+		"Content-Type": "application/xml"
+	}
+}) });
+/**
+* Combined Activation contract
+*/
+const activationContract = { activate };
+
+//#endregion
+//#region src/adt/datapreview/schema.ts
+/**
+* Hand-built Serializable schema for the data preview freestyle response.
+*
+* Shape mirrors the ts-xsd `TypedSchema` pattern so it plugs into speci's
+* `Inferrable`/`Serializable` type inference (`_infer`, `parse`, `build`).
+*
+* The adapter calls `schema.parse(raw)` / `schema.build(data)`, so we keep
+* both sides as plain JSON (de)serialisation.
+*/
+const dataPreviewFreestyleResponseSchema = {
+	_infer: void 0,
+	parse: (raw) => {
+		if (raw == null || raw === "") return {};
+		return JSON.parse(raw);
+	},
+	build: (data) => JSON.stringify(data)
+};
+/**
+* Request-body schema: the endpoint accepts a raw SQL SELECT string as
+* `text/plain`. We still model it as a Serializable so speci correctly
+* infers the `string` body parameter at the client call site.
+*/
+const dataPreviewFreestyleRequestSchema = {
+	_infer: void 0,
+	parse: (raw) => raw,
+	build: (data) => data
+};
+
+//#endregion
+//#region src/adt/datapreview/freestyle.ts
+/**
+* /sap/bc/adt/datapreview/freestyle
+*
+* Executes an ABAP Open SQL SELECT statement and returns the result set as
+* JSON.  Mirrors sapcli's `datapreview osql` command and the adt CLI
+* `datapreview osql` command.
+*
+*   POST /sap/bc/adt/datapreview/freestyle?rowCount=<n>&outputFormat=json[&noaging=true]
+*   Content-Type: text/plain
+*   Accept:       application/json
+*   Body:         raw ABAP SQL SELECT statement
+*/
+const freestyle = { post: (query) => http$1.post("/sap/bc/adt/datapreview/freestyle", {
+	body: dataPreviewFreestyleRequestSchema,
+	responses: { 200: dataPreviewFreestyleResponseSchema },
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "text/plain"
+	},
+	query: {
+		outputFormat: query?.outputFormat ?? "json",
+		...query?.rowCount != null ? { rowCount: query.rowCount } : {},
+		...query?.noaging ? { noaging: true } : {}
+	}
+}) };
+
+//#endregion
+//#region src/adt/datapreview/index.ts
+/**
+* /sap/bc/adt/datapreview
+*
+* ADT Data Preview endpoints (ABAP SQL execution, value helps, etc.)
+*/
+const datapreviewContract = { freestyle };
+
+//#endregion
+//#region src/adt/runtime/traces/coverage/measurements.ts
+/**
+* /sap/bc/adt/runtime/traces/coverage/measurements/{id}
+*
+* POST returns the ABAP coverage tree (cov:result) for a previously
+* created measurement. Used as the second step of the aunit → coverage
+* flow: aunit run → atom:link to measurement → POST this endpoint.
+*
+* Content-Type: application/xml+scov
+* Accept:       application/xml+scov
+*/
+const SCOV_CONTENT_TYPE$1 = "application/xml+scov";
+const measurements = contract({ post: (identifier) => http$1.post(`/sap/bc/adt/runtime/traces/coverage/measurements/${identifier}`, {
+	query: { withAdditionalTypeInfo: true },
+	responses: { 200: acoverageResult },
+	headers: {
+		Accept: SCOV_CONTENT_TYPE$1,
+		"Content-Type": SCOV_CONTENT_TYPE$1
+	}
+}) });
+
+//#endregion
+//#region src/adt/runtime/traces/coverage/statements.ts
+/**
+* /sap/bc/adt/runtime/traces/coverage/results/{id}/statements
+*
+* GET returns the cov:statementsBulkResponse with per-method statement
+* / branch / procedure coverage details.
+*
+* Content-Type: application/xml+scov
+*/
+const SCOV_CONTENT_TYPE = "application/xml+scov";
+const statements = contract({ get: (identifier) => http$1.get(`/sap/bc/adt/runtime/traces/coverage/results/${identifier}/statements`, {
+	responses: { 200: acoverageStatements },
+	headers: { Accept: SCOV_CONTENT_TYPE }
+}) });
+
+//#endregion
+//#region src/adt/runtime/traces/coverage/index.ts
+/**
+* /sap/bc/adt/runtime/traces/coverage
+*
+* ABAP Coverage endpoints. Used as a follow-up to ABAP Unit runs that
+* request coverage — the aunit runResult contains an atom:link pointing
+* to a measurement ID which is then POSTed here.
+*/
+const coverageContract = {
+	measurements,
+	statements
+};
+
+//#endregion
+//#region src/adt/runtime/schema.ts
+function parseJsonOrRaw$1(raw) {
+	if (!raw) return {};
+	const trimmed = raw.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) return JSON.parse(trimmed);
+	return { raw };
+}
+function buildJson(value) {
+	return JSON.stringify(value);
+}
+const runtimeDumpListSchema = {
+	_infer: void 0,
+	parse: (raw) => parseJsonOrRaw$1(raw),
+	build: (value) => buildJson(value)
+};
+const runtimeDumpDetailSchema = {
+	_infer: void 0,
+	parse: (raw) => parseJsonOrRaw$1(raw),
+	build: (value) => buildJson(value)
+};
+const runtimeTraceListSchema = {
+	_infer: void 0,
+	parse: (raw) => parseJsonOrRaw$1(raw),
+	build: (value) => buildJson(value)
+};
+const runtimeTraceDetailSchema = {
+	_infer: void 0,
+	parse: (raw) => parseJsonOrRaw$1(raw),
+	build: (value) => buildJson(value)
+};
+
+//#endregion
+//#region src/adt/runtime/traces/profile.ts
+/**
+* /sap/bc/adt/runtime/traces
+*
+* Runtime trace list and detail endpoints used by diagnostics tooling.
+*/
+const profile = contract({
+	list: () => http$1.get("/sap/bc/adt/runtime/traces", {
+		responses: { 200: runtimeTraceListSchema },
+		headers: { Accept: "application/json" }
+	}),
+	hitlist: (id) => http$1.get(`/sap/bc/adt/runtime/traces/${id}/hitlist`, {
+		responses: { 200: runtimeTraceDetailSchema },
+		headers: { Accept: "application/json" }
+	}),
+	dbAccesses: (id) => http$1.get(`/sap/bc/adt/runtime/traces/${id}/dbaccesses`, {
+		responses: { 200: runtimeTraceDetailSchema },
+		headers: { Accept: "application/json" }
+	})
+});
+
+//#endregion
+//#region src/adt/runtime/traces/index.ts
+/**
+* /sap/bc/adt/runtime/traces
+*
+* Runtime trace endpoints (currently only ABAP coverage).
+*/
+const tracesContract = {
+	coverage: coverageContract,
+	profile
+};
+
+//#endregion
+//#region src/adt/runtime/dumps.ts
+/**
+* /sap/bc/adt/runtime/dumps
+*
+* Short dump listing and details.
+*/
+const dumps = contract({
+	list: (query) => http$1.get("/sap/bc/adt/runtime/dumps", {
+		responses: { 200: runtimeDumpListSchema },
+		headers: { Accept: "application/json" },
+		query: {
+			...query?.user ? { user: query.user } : {},
+			...query?.maxResults != null ? { maxResults: query.maxResults } : {}
+		}
+	}),
+	get: (id) => http$1.get(`/sap/bc/adt/runtime/dumps/${id}`, {
+		responses: { 200: runtimeDumpDetailSchema },
+		headers: { Accept: "application/json" }
+	})
+});
+
+//#endregion
+//#region src/adt/runtime/index.ts
+/**
+* /sap/bc/adt/runtime
+*
+* ABAP runtime endpoints (traces, coverage, …).
+*/
+const runtimeContract = {
+	traces: tracesContract,
+	dumps
+};
+
+//#endregion
+//#region src/adt/gcts/schema.ts
+function jsonSchema$1() {
+	return {
+		_infer: void 0,
+		parse: (raw) => {
+			if (raw == null || raw === "") return {};
+			return JSON.parse(raw);
+		},
+		build: (data) => JSON.stringify(data)
+	};
+}
+const gctsRepositoriesSchema = jsonSchema$1();
+const gctsRepositorySchema = jsonSchema$1();
+const gctsCreateRepositoryBodySchema = jsonSchema$1();
+const gctsSetItemBodySchema = jsonSchema$1();
+const gctsBranchesSchema = jsonSchema$1();
+const gctsCreateBranchBodySchema = jsonSchema$1();
+const gctsCreateBranchResponseSchema = jsonSchema$1();
+const gctsSetConfigBodySchema = jsonSchema$1();
+const gctsConfigSchema = jsonSchema$1();
+const gctsLogSchema = jsonSchema$1();
+const gctsPullSchema = jsonSchema$1();
+const gctsObjectsSchema = jsonSchema$1();
+const gctsCommitBodySchema = jsonSchema$1();
+const gctsCommitResponseSchema = jsonSchema$1();
+const gctsGenericOkSchema = jsonSchema$1();
+
+//#endregion
+//#region src/adt/gcts/repository.ts
+/**
+* /sap/bc/cts_abapvcs/repository/**
+*
+* gCTS repository endpoints. Shapes mirror sapcli's
+* `Repository` / `simple.fetch_repos` behaviour.
+*/
+const BASE$3 = "/sap/bc/cts_abapvcs/repository";
+/** List all repositories (GET /repository). */
+const list$4 = () => http$1.get(BASE$3, {
+	responses: { 200: gctsRepositoriesSchema },
+	headers: { Accept: "application/json" }
+});
+/** Get a single repository (GET /repository/<rid>). */
+const get$4 = (rid) => http$1.get(`${BASE$3}/${rid}`, {
+	responses: { 200: gctsRepositorySchema },
+	headers: { Accept: "application/json" }
+});
+/** Create a new repository (POST /repository). */
+const create$1 = () => http$1.post(BASE$3, {
+	body: gctsCreateRepositoryBodySchema,
+	responses: {
+		201: gctsRepositorySchema,
+		200: gctsRepositorySchema
+	},
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "application/json"
+	}
+});
+/** Delete a repository (DELETE /repository/<rid>). */
+const del$2 = (rid) => http$1.delete(`${BASE$3}/${rid}`, {
+	responses: {
+		200: gctsGenericOkSchema,
+		204: gctsGenericOkSchema
+	},
+	headers: { Accept: "application/json" }
+});
+/** Clone (POST /repository/<rid>/clone). */
+const clone = (rid) => http$1.post(`${BASE$3}/${rid}/clone`, {
+	responses: { 200: gctsGenericOkSchema },
+	headers: { Accept: "application/json" }
+});
+/** Pull (GET /repository/<rid>/pullByCommit). */
+const pull = (rid) => http$1.get(`${BASE$3}/${rid}/pullByCommit`, {
+	responses: { 200: gctsPullSchema },
+	headers: { Accept: "application/json" }
+});
+/** Push (GET /repository/<rid>/push) — gCTS uses GET, not POST. */
+const push = (rid) => http$1.get(`${BASE$3}/${rid}/push`, {
+	responses: { 200: gctsGenericOkSchema },
+	headers: { Accept: "application/json" }
+});
+/**
+* Checkout (GET /repository/<rid>/branches/<currentBranch>/switch?branch=X).
+* Caller must supply both the *current* branch (path) and the *target* branch
+* (query) — mirrors sapcli's `Repository.checkout`.
+*/
+const checkout = (rid, currentBranch, targetBranch) => http$1.get(`${BASE$3}/${rid}/branches/${currentBranch}/switch`, {
+	query: { branch: targetBranch },
+	responses: { 200: gctsGenericOkSchema },
+	headers: { Accept: "application/json" }
+});
+/** Commit history (GET /repository/<rid>/getCommit). */
+const log = (rid) => http$1.get(`${BASE$3}/${rid}/getCommit`, {
+	responses: { 200: gctsLogSchema },
+	headers: { Accept: "application/json" }
+});
+/** Object list (GET /repository/<rid>/getObjects). */
+const objects = (rid) => http$1.get(`${BASE$3}/${rid}/getObjects`, {
+	responses: { 200: gctsObjectsSchema },
+	headers: { Accept: "application/json" }
+});
+/**
+* Set a repository property (POST /repository/<rid>).
+* Body is `{ <property>: <value> }`, e.g. `{ role: 'TARGET' }` or
+* `{ url: 'https://…' }`.
+*/
+const setItem = (rid) => http$1.post(`${BASE$3}/${rid}`, {
+	body: gctsSetItemBodySchema,
+	responses: { 200: gctsGenericOkSchema },
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "application/json"
+	}
+});
+const repository = {
+	list: list$4,
+	get: get$4,
+	create: create$1,
+	delete: del$2,
+	clone,
+	pull,
+	push,
+	checkout,
+	log,
+	objects,
+	setItem
+};
+
+//#endregion
+//#region src/adt/gcts/branches.ts
+/**
+* /sap/bc/cts_abapvcs/repository/<rid>/branches
+*
+* Branch management endpoints.
+*/
+const base$1 = (rid) => `/sap/bc/cts_abapvcs/repository/${rid}/branches`;
+const list$3 = (rid) => http$1.get(base$1(rid), {
+	responses: { 200: gctsBranchesSchema },
+	headers: { Accept: "application/json" }
+});
+const create = (rid) => http$1.post(base$1(rid), {
+	body: gctsCreateBranchBodySchema,
+	responses: { 200: gctsCreateBranchResponseSchema },
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "application/json"
+	}
+});
+const del$1 = (rid, name) => http$1.delete(`${base$1(rid)}/${name}`, {
+	responses: { 200: gctsGenericOkSchema },
+	headers: { Accept: "application/json" }
+});
+/**
+* Switch branches (GET /repository/<rid>/branches/<current>/switch?branch=X).
+* Alias of `repository.checkout` — exposed here for discoverability when
+* working with the `branches` sub-surface.
+*/
+const switchBranch = (rid, currentBranch, target) => http$1.get(`${base$1(rid)}/${currentBranch}/switch`, {
+	query: { branch: target },
+	responses: { 200: gctsGenericOkSchema },
+	headers: { Accept: "application/json" }
+});
+const branches = {
+	list: list$3,
+	create,
+	delete: del$1,
+	switch: switchBranch
+};
+
+//#endregion
+//#region src/adt/gcts/commits.ts
+/**
+* /sap/bc/cts_abapvcs/repository/<rid>/commit
+*
+* Commit endpoint. Shapes mirror sapcli's
+* `Repository.commit` / `commit_package` / `commit_transport`.
+*/
+const commit = (rid) => http$1.post(`/sap/bc/cts_abapvcs/repository/${rid}/commit`, {
+	body: gctsCommitBodySchema,
+	responses: { 200: gctsCommitResponseSchema },
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "application/json"
+	}
+});
+const commits = { commit };
+
+//#endregion
+//#region src/adt/gcts/config.ts
+/**
+* /sap/bc/cts_abapvcs/repository/<rid>/config
+*
+* Repository configuration endpoints (key/value pairs).
+*/
+const base = (rid) => `/sap/bc/cts_abapvcs/repository/${rid}/config`;
+/** GET single config value: /repository/<rid>/config/<key>. */
+const get$3 = (rid, key) => http$1.get(`${base(rid)}/${key}`, {
+	responses: { 200: gctsConfigSchema },
+	headers: { Accept: "application/json" }
+});
+/** POST /repository/<rid>/config — body `{ key, value }`. */
+const set = (rid) => http$1.post(base(rid), {
+	body: gctsSetConfigBodySchema,
+	responses: { 200: gctsGenericOkSchema },
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "application/json"
+	}
+});
+/** DELETE /repository/<rid>/config/<key>. */
+const del = (rid, key) => http$1.delete(`${base(rid)}/${key}`, {
+	responses: { 200: gctsGenericOkSchema },
+	headers: { Accept: "application/json" }
+});
+const config = {
+	get: get$3,
+	set,
+	delete: del
+};
+
+//#endregion
+//#region src/adt/gcts/index.ts
+/**
+* /sap/bc/cts_abapvcs — gCTS (git-enabled CTS) contracts.
+*
+* Separate REST surface from /sap/bc/adt. Exposed as `client.adt.gcts.*`
+* for parity with sapcli's `sap gcts` CLI surface.
+*/
+const gctsContract = {
+	repository,
+	branches,
+	commits,
+	config
+};
+
+//#endregion
+//#region src/adt/bo/behaviordefinitions.ts
+/**
+* ADT Behavior Definition (BDEF) Contract
+*
+* Endpoint: /sap/bc/adt/bo/behaviordefinitions/{name}
+*           /sap/bc/adt/bo/behaviordefinitions/{name}/source/main
+*
+* Object type: BDEF/BDO
+* Content-Type: application/vnd.sap.adt.blues.v1+xml
+*
+* SAP wraps BDEF metadata in the shared `blue:blueSource` wrapper
+* (namespace http://www.sap.com/wbobj/blue) that extends
+* abapsource:AbapSourceMainObject — the same envelope used by
+* DDIC TABL/Structure responses. The BDEF source (`.abdl`) is
+* served as text/plain via `source/main`.
+*
+* Reference: sapcli `sap/adt/objects.py` (class BehaviorDefinition).
+*/
+/**
+* /sap/bc/adt/bo/behaviordefinitions
+* Full CRUD operations for ABAP Behavior Definitions (RAP).
+*
+* Includes:
+*  - Basic CRUD: get, post, put, delete
+*  - Lock/Unlock: lock, unlock
+*  - Object structure: objectstructure
+*  - Source code: source.main.get/put  (text/plain .abdl)
+*/
+const behaviordefinitionsContract = crud({
+	basePath: "/sap/bc/adt/bo/behaviordefinitions",
+	schema: blueSource,
+	contentType: "application/vnd.sap.adt.blues.v1+xml",
+	accept: "application/vnd.sap.adt.blues.v1+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/bo/index.ts
+const boContract = { behaviordefinitions: behaviordefinitionsContract };
+
+//#endregion
+//#region src/adt/businessservices/bindings.ts
+/**
+* ADT RAP Service Binding (SRVB) Contract
+*
+* Endpoint: /sap/bc/adt/businessservices/bindings
+* Content-Type: application/vnd.sap.adt.businessservices.servicebinding.v1+xml
+* Object type: SRVB/SVB
+*
+* RAP Service Binding — binds a Service Definition (SRVD) to a runtime
+* protocol (OData V2/V4, INA, SQL). Unlike BDEF/SRVD, SRVB is **metadata
+* only** — there is no `.abdl`/`.asrvd`-style source text. The binding
+* XML carries the service + protocol references.
+*
+* Extra operations vs plain `crud()`:
+*   - publish   → POST   {basePath}/{name}/publishedstates
+*   - unpublish → DELETE {basePath}/{name}/publishedstates
+*
+* Reference: abapGit handler zcl_abapgit_object_srvb.
+*/
+const basePath = "/sap/bc/adt/businessservices/bindings";
+const nameTransform = (n) => n.toLowerCase();
+const baseContract = crud({
+	basePath,
+	schema: servicebinding,
+	contentType: "application/vnd.sap.adt.businessservices.servicebinding.v1+xml",
+	accept: "application/vnd.sap.adt.businessservices.servicebinding.v1+xml"
+});
+/**
+* Publish/unpublish extension for SRVB.
+*
+*  - publish:   POST {basePath}/{name}/publishedstates
+*               Activates the binding in the SAP Gateway.
+*  - unpublish: DELETE {basePath}/{name}/publishedstates
+*               Deactivates the binding.
+*/
+const bindingsContract = {
+	...baseContract,
+	publish: (name) => http.post(`${basePath}/${nameTransform(name)}/publishedstates`, {
+		responses: { 200: void 0 },
+		headers: {
+			Accept: "application/json",
+			"Content-Type": "application/json"
+		}
+	}),
+	unpublish: (name) => http.delete(`${basePath}/${nameTransform(name)}/publishedstates`, {
+		responses: { 204: void 0 },
+		headers: { Accept: "application/json" }
+	})
+};
+
+//#endregion
+//#region src/adt/businessservices/index.ts
+const businessservicesContract = { bindings: bindingsContract };
+
+//#endregion
+//#region src/adt/enhancements/enhoxhh.ts
+/**
+* ADT BAdI / Enhancement Implementation (ENHO) Contract
+*
+* Endpoints:
+*   /sap/bc/adt/enhancements/enhoxhh/{name}
+*   /sap/bc/adt/enhancements/enhoxhh/{name}/source/main
+*
+* Object type: ENHO/XHH   (enhancement implementation, BAdI container)
+* Content-Type: application/vnd.sap.adt.enhancements.enhoxhh.v1+xml
+*
+* SAP wraps the enhancement implementation in an
+* `enh:enhancementImplementation` element extending
+* `adtcore:AdtMainObject`. The BAdI implementations themselves live
+* inside the text payload served via `source/main`.
+*
+* The full XSD at `packages/adt-schemas/.xsd/sap/enhancements.xsd`
+* models the heavyweight emf tree (sourceCodePlugin, BAdI entries,
+* etc.). For CLI / MCP use we only need the AdtMainObject envelope —
+* same pattern as bdef's `blueSource` wrapper.
+*
+* sapcli reference: `sap/cli/badi.py`. In sapcli, `sap badi` lists the
+* BAdIs carried by a given Enhancement Implementation name (`-i` flag).
+*/
+/**
+* /sap/bc/adt/enhancements/enhoxhh
+*
+* CRUD + lock/unlock + source/main (`/source/main` text body).
+*/
+const enhoxhhContract = crud({
+	basePath: "/sap/bc/adt/enhancements/enhoxhh",
+	schema: badi,
+	contentType: "application/vnd.sap.adt.enhancements.enhoxhh.v1+xml",
+	accept: "application/vnd.sap.adt.enhancements.enhoxhh.v1+xml",
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/enhancements/index.ts
+const enhancementsContract = { enhoxhh: enhoxhhContract };
+
+//#endregion
+//#region src/adt/uifsa/schema.ts
+function jsonSchema() {
+	return {
+		_infer: void 0,
+		parse: (raw) => {
+			if (raw == null || raw === "") return {};
+			return JSON.parse(raw);
+		},
+		build: (data) => JSON.stringify(data)
+	};
+}
+const flpCatalogListSchema = jsonSchema();
+const flpCatalogSchema = jsonSchema();
+const flpGroupListSchema = jsonSchema();
+const flpGroupSchema = jsonSchema();
+const flpTileListSchema = jsonSchema();
+const flpTileSchema = jsonSchema();
+/** Extract `d.results` from an OData feed response. */
+function normalizeOdataFeed(response) {
+	return response?.d?.results ?? [];
+}
+/** Extract `d` from an OData single-entity response. */
+function normalizeOdataEntity(response) {
+	return response?.d;
+}
+
+//#endregion
+//#region src/adt/uifsa/catalogs.ts
+/**
+* Fiori Launchpad catalogs — `/sap/opu/odata/UI2/PAGE_BUILDER_PERS/Catalogs`.
+*
+* Read-only in v1 (E14 scope). Create/delete are handled by
+* `sap/flp/service.py` in sapcli but are out of scope here.
+*/
+const BASE$2 = "/sap/opu/odata/UI2/PAGE_BUILDER_PERS/Catalogs";
+/** Encode an OData entity key for use in the URL segment `Catalogs('<id>')`. */
+function encodeKey$2(id) {
+	return `'${encodeURIComponent(id)}'`;
+}
+/** List all catalogs. */
+const list$2 = () => http$1.get(BASE$2, {
+	query: { $format: "json" },
+	responses: { 200: flpCatalogListSchema },
+	headers: { Accept: "application/json" }
+});
+/** Get a single catalog by its ID (e.g. `X-SAP-UI2-CATALOGPAGE:SAP_A4C…`). */
+const get$2 = (id) => http$1.get(`${BASE$2}(${encodeKey$2(id)})`, {
+	query: { $format: "json" },
+	responses: { 200: flpCatalogSchema },
+	headers: { Accept: "application/json" }
+});
+/** List tiles (chips) that belong to a specific catalog. */
+const tiles$1 = (id) => http$1.get(`${BASE$2}(${encodeKey$2(id)})/Chips`, {
+	query: { $format: "json" },
+	responses: { 200: flpTileListSchema },
+	headers: { Accept: "application/json" }
+});
+const catalogs = {
+	list: list$2,
+	get: get$2,
+	tiles: tiles$1
+};
+
+//#endregion
+//#region src/adt/uifsa/groups.ts
+/**
+* Fiori Launchpad groups / pages — `/sap/opu/odata/UI2/PAGE_BUILDER_PERS/Pages`.
+*
+* Read-only in v1 (E14 scope).
+*/
+const BASE$1 = "/sap/opu/odata/UI2/PAGE_BUILDER_PERS/Pages";
+function encodeKey$1(id) {
+	return `'${encodeURIComponent(id)}'`;
+}
+/** List all pages / groups. */
+const list$1 = () => http$1.get(BASE$1, {
+	query: { $format: "json" },
+	responses: { 200: flpGroupListSchema },
+	headers: { Accept: "application/json" }
+});
+/** Get a single page / group by ID (e.g. `/UI2/SAMPLE_PAGE`). */
+const get$1 = (id) => http$1.get(`${BASE$1}(${encodeKey$1(id)})`, {
+	query: { $format: "json" },
+	responses: { 200: flpGroupSchema },
+	headers: { Accept: "application/json" }
+});
+const groups = {
+	list: list$1,
+	get: get$1
+};
+
+//#endregion
+//#region src/adt/uifsa/tiles.ts
+/**
+* Fiori Launchpad tiles (CHIPs) — `/sap/opu/odata/UI2/PAGE_BUILDER_PERS/Chips`.
+*
+* A "tile" in FLP is actually a CHIP (Collaborative Human Interface Part)
+* instance attached to a catalog / page. The Page Builder OData service
+* exposes them through the `Chips` entity set.
+*
+* Read-only in v1 (E14 scope).
+*/
+const BASE = "/sap/opu/odata/UI2/PAGE_BUILDER_PERS/Chips";
+function encodeKey(id) {
+	return `'${encodeURIComponent(id)}'`;
+}
+/** List all tiles known to the system. */
+const list = () => http$1.get(BASE, {
+	query: { $format: "json" },
+	responses: { 200: flpTileListSchema },
+	headers: { Accept: "application/json" }
+});
+/** Get a single tile by its CHIP ID (e.g. `X-SAP-UI2-CHIP:/UI2/STATIC_APPLAUNCHER`). */
+const get = (id) => http$1.get(`${BASE}(${encodeKey(id)})`, {
+	query: { $format: "json" },
+	responses: { 200: flpTileSchema },
+	headers: { Accept: "application/json" }
+});
+const tiles = {
+	list,
+	get
+};
+
+//#endregion
+//#region src/adt/uifsa/index.ts
+/**
+* FLP (Fiori Launchpad) contracts — `client.adt.flp.*`.
+*
+* NOTE: The directory is named `uifsa` to match the epic spec
+* (E14 pointed at `/sap/bc/adt/uifsa/`), but the actual endpoints
+* live on the Page Builder OData service (`/sap/opu/odata/UI2/
+* PAGE_BUILDER_PERS/`). The namespace on the client is `flp` —
+* matching sapcli's user-facing command name.
+*/
+const flpContract = {
+	catalogs,
+	groups,
+	tiles
+};
+
+//#endregion
+//#region src/adt/codeassistance/schema.ts
+function parseJsonOrRaw(raw) {
+	if (!raw) return {};
+	const trimmed = raw.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) return JSON.parse(trimmed);
+	return { raw };
+}
+const completionResponseSchema = {
+	_infer: void 0,
+	parse: parseJsonOrRaw,
+	build: (value) => JSON.stringify(value)
+};
+const completionRequestSchema = {
+	_infer: void 0,
+	parse: (raw) => {
+		if (!raw) return {};
+		const trimmed = raw.trim();
+		if (trimmed.startsWith("{") || trimmed.startsWith("[")) return JSON.parse(trimmed);
+		return { source: raw };
+	},
+	build: (value) => JSON.stringify(value)
+};
+
+//#endregion
+//#region src/adt/codeassistance/completion.ts
+/**
+* /sap/bc/adt/codeassistance/completion
+*/
+const completion = contract({ post: (query) => http$1.post("/sap/bc/adt/codeassistance/completion", {
+	body: completionRequestSchema,
+	responses: { 200: completionResponseSchema },
+	headers: {
+		Accept: "application/json",
+		"Content-Type": "application/json"
+	},
+	query
+}) });
+
+//#endregion
+//#region src/adt/codeassistance/index.ts
+const codeassistanceContract = { completion };
+
+//#endregion
+//#region src/adt/index.ts
+/**
+* Complete ADT Contract
+*/
+const adtContract = {
+	cts: ctsContract,
+	atc: atcContract,
+	aunit: aunitContract,
+	oo: ooContract,
+	discovery: discoveryContract,
+	packages: packagesContract,
+	core: coreContract,
+	repository: repositoryContract,
+	programs: programsModuleContract,
+	functions: functionsContract,
+	ddic: ddicContract,
+	system: systemContract,
+	checkruns: checkrunsContract,
+	activation: activationContract,
+	datapreview: datapreviewContract,
+	runtime: runtimeContract,
+	gcts: gctsContract,
+	bo: boContract,
+	businessservices: businessservicesContract,
+	enhancements: enhancementsContract,
+	flp: flpContract,
+	codeassistance: codeassistanceContract
+};
+
+//#endregion
+//#region src/base.ts
+/**
+* Create a typed ADT REST client.
+*
+* Contract is already known - just pass adapter options.
+*/
+function createAdtClient(options) {
+	return createClient(adtContract, options);
+}
+/**
+* Identity function for contract definitions.
+*
+* Schemas from ./schemas are already speci-compatible,
+* so this is just a pass-through for type safety and documentation.
+*
+* @example
+* ```ts
+* import { configurations } from './schemas';
+* import { contract, http } from '../base';
+*
+* export const myContract = contract({
+*   get: () => http.get('/endpoint', {
+*     responses: { 200: configurations },
+*   }),
+* });
+* // Type is automatically inferred from configurations.parse() return type
+* ```
+*/
+function contract(definition) {
+	return definition;
+}
+
+//#endregion
+export { activationContract as $, normalizeTransportFindResponse as $t, gctsCreateBranchResponseSchema as A, USAGEREFS_NAMESPACE as At, runtimeContract as B, discoveryContract as Bt, behaviordefinitionsContract as C, repositoryContract as Ct, gctsCommitResponseSchema as D, SCOPE_RESPONSE_MIME as Dt, gctsCommitBodySchema as E, SCOPE_REQUEST_MIME as Et, gctsPullSchema as F, coreContract as Ft, runtimeDumpListSchema as G, aunitContract as Gt, tracesContract as H, classrunContract as Ht, gctsRepositoriesSchema as I, httpContract as It, coverageContract as J, resultsContract as Jt, runtimeTraceDetailSchema as K, extractCoverageMeasurementId as Kt, gctsRepositorySchema as L, systeminformationContract as Lt, gctsGenericOkSchema as M, buildUsageScopeRequestXml as Mt, gctsLogSchema as N, usageReferencesContract as Nt, gctsConfigSchema as O, SEARCH_REQUEST_MIME as Ot, gctsObjectsSchema as P, searchContract as Pt, freestyle as Q, TransportStatus as Qt, gctsSetConfigBodySchema as R, sessionsContract as Rt, boContract as S, programsContract as St, gctsBranchesSchema as T, informationsystemContract as Tt, profile as U, interfacesContract as Ut, dumps as V, ooContract as Vt, runtimeDumpDetailSchema as W, classesContract as Wt, measurements as X, ctsContract as Xt, statements as Y, worklistsContract as Yt, datapreviewContract as Z, TransportFunction as Zt, normalizeOdataFeed as _, functionsContract as _t, codeassistanceContract as a, srvdContract as at, businessservicesContract as b, programsModuleContract as bt, completionResponseSchema as c, dclSourcesContract as ct, flpCatalogSchema as d, tabletypesContract as dt, transports as en, checkrunsContract as et, flpGroupListSchema as f, tablesettingsContract as ft, normalizeOdataEntity as g, domainsContract as gt, flpTileSchema as h, dataelementsContract as ht, adtContract as i, ddicContract as it, gctsCreateRepositoryBodySchema as j, buildUsageReferenceRequestXml as jt, gctsCreateBranchBodySchema as k, SEARCH_RESPONSE_MIME as kt, flpContract as l, ddlContract as lt, flpTileListSchema as m, structuresContract as mt, createAdtClient as n, repo as nn, psesContract as nt, completion as o, srvdSourcesContract as ot, flpGroupSchema as p, tablesContract as pt, runtimeTraceListSchema as q, atcContract as qt, http$1 as r, usersContract as rt, completionRequestSchema as s, dclContract as st, contract as t, crud as tn, systemContract as tt, flpCatalogListSchema as u, ddlSourcesContract as ut, enhancementsContract as v, functionModulesContract as vt, gctsContract as w, objectstructureContract as wt, bindingsContract as x, includesContract as xt, enhoxhhContract as y, functionGroupsContract as yt, gctsSetItemBodySchema as z, packagesContract as zt };
+//# sourceMappingURL=base-BsgeOhzu.mjs.map