@abapify/adt-contracts 0.4.0 → 0.4.3

package/dist/base-CJ5t6dbP.mjs

@@ -0,0 +1,3056 @@
+import { acoverageResult, acoverageStatements, adtcore, atc, atcRun, atcworklist, atomFeed, aunitResult, aunitRun, badi, blueSource, checkrun, classes, configuration, configurations as configurations$1, dataelementWrapper, dclSource, ddlSource, ddlxSource, discovery, domain, dtebSource, fmodules, groups as groups$1, http as http$2, includes, interfaces, objectProperties, 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 {
+		/** Schema for XML serialization/deserialization */
+		bodySchema: schema,
+		/**
+		* GET {basePath}/{name}
+		* Retrieve object metadata
+		*/
+		get: (name, queryOptions) => http.get(`${basePath}/${nameTransform(name)}`, {
+			responses: { 200: schema },
+			headers: { Accept: accept },
+			query: queryOptions?.version ? { version: queryOptions.version } : void 0
+		}),
+		/**
+		* POST {basePath}
+		* Create a new object
+		*/
+		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 {basePath}/{name}
+		* Update object metadata
+		*/
+		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 {basePath}/{name}
+		* Delete object
+		*/
+		delete: (name, queryOptions) => http.delete(`${basePath}/${nameTransform(name)}`, {
+			responses: { 204: void 0 },
+			query: {
+				...queryOptions?.corrNr ? { corrNr: queryOptions.corrNr } : {},
+				...queryOptions?.lockHandle ? { lockHandle: queryOptions.lockHandle } : {}
+			}
+		}),
+		/**
+		* POST {basePath}/{name}?_action=LOCK
+		* Lock object for modification
+		*
+		* Response contains lock handle in XML format:
+		* <asx:abap>...<DATA><LOCK_HANDLE>xxx</LOCK_HANDLE><CORRNR>yyy</CORRNR>...</DATA>...</asx:abap>
+		*/
+		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 } : {}
+			}
+		}),
+		/**
+		* POST {basePath}/{name}?_action=UNLOCK
+		* Unlock object
+		*/
+		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
+			}
+		}),
+		/**
+		* GET {basePath}/{name}/objectstructure
+		* Get object structure (includes, methods, attributes, etc.)
+		*/
+		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 /sap/bc/adt/cts/transportrequests/valuehelp/attribute{?maxItemCount}{&name}
+*/
+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 /sap/bc/adt/cts/transportrequests/valuehelp/target{?maxItemCount}{&name}
+*/
+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 /sap/bc/adt/cts/transportrequests/valuehelp/ctsproject{?maxItemCount}{&name}
+*/
+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 /sap/bc/adt/cts/transportrequests/valuehelp/object/{field}{?maxItemCount}{&name}
+*/
+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 list of search configurations */
+	get: () => http$1.get("/sap/bc/adt/cts/transportrequests/searchconfiguration/configurations", {
+		responses: { 200: configurations$1 },
+		headers: { Accept: "application/vnd.sap.adt.configurations.v1+xml" }
+	}),
+	/** GET a specific configuration by ID */
+	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 update a specific configuration by ID - body type inferred from schema
+	*  Note: If-Match header is automatically added by the adapter from cached ETag
+	*/
+	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 default search configuration metadata */
+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/change-owner-schema.ts
+function isChangeOwnerRoot(root) {
+	if (typeof root !== "object" || root === null) return false;
+	const { useraction, number, targetuser } = root;
+	return useraction === "changeowner" && typeof number === "string" && number.length > 0 && typeof targetuser === "string" && targetuser.length > 0;
+}
+/**
+* Narrow request schema for the CTS change-owner action.
+*
+* SAP models these attributes on the broader transport-management root. This
+* wrapper keeps the call-site body narrow while delegating XML parsing and
+* serialization to that generated SAP schema.
+*/
+const changeOwnerBodySchema = {
+	_infer: void 0,
+	parse: (raw) => {
+		const root = transportmanagment.parse(raw)?.root;
+		if (!isChangeOwnerRoot(root)) throw new Error("Invalid CTS change-owner body");
+		return { root: {
+			number: root.number,
+			targetuser: root.targetuser,
+			useraction: "changeowner"
+		} };
+	},
+	build: (body) => transportmanagment.build(body)
+};
+
+//#endregion
+//#region src/adt/cts/transportrequests/add-task-schema.ts
+/** Narrow body used by SAP's hypermedia `newtask` relation. */
+const addTaskBodySchema = {
+	_infer: void 0,
+	parse: (raw) => {
+		const root = transportmanagment.parse(raw)?.root;
+		if (!root || !root.targetuser) throw new Error("Invalid CTS add-task body");
+		return { root: { targetuser: root.targetuser } };
+	},
+	build: (body) => transportmanagment.build(body)
+};
+
+//#endregion
+//#region src/adt/cts/transportrequests/useraction.ts
+/**
+* /sap/bc/adt/cts/transportrequests - user-action body endpoints
+*
+* SAP ADT uses distinct lifecycle endpoints for release, changeowner, and
+* newrequest and newtask actions. This file exposes typed contracts for them.
+*
+*   release       → POST /{trkorr}/newreleasejobs (no body)
+*   changeowner   → PUT  /{trkorr}    (requires tm:number and tm:targetuser)
+*   newtask       → POST /{trkorr}/tasks (requires tm:targetuser)
+*   newrequest    → POST /            (creates a new transport request)
+*/
+const CONTENT_TYPE = "application/vnd.sap.adt.transportorganizer.v1+xml";
+const useraction = {
+	/**
+	* Start and synchronously report a transport/task release job.
+	*/
+	release: (trkorr) => http$1.post(`/sap/bc/adt/cts/transportrequests/${trkorr}/newreleasejobs`, {
+		responses: { 200: transportmanagment },
+		headers: { Accept: CONTENT_TYPE }
+	}),
+	/**
+	* PUT /{trkorr} with useraction="changeowner".
+	*/
+	reassign: (trkorr, _options) => http$1.put(`/sap/bc/adt/cts/transportrequests/${trkorr}`, {
+		body: changeOwnerBodySchema,
+		responses: { 200: transportmanagmentSingle },
+		headers: {
+			Accept: CONTENT_TYPE,
+			"Content-Type": CONTENT_TYPE
+		}
+	}),
+	/** Create a modifiable task below an existing request. */
+	addTask: (trkorr, _options) => http$1.post(`/sap/bc/adt/cts/transportrequests/${trkorr}/tasks`, {
+		body: addTaskBodySchema,
+		responses: { 200: transportmanagment },
+		headers: {
+			Accept: CONTENT_TYPE,
+			"Content-Type": CONTENT_TYPE
+		}
+	}),
+	/**
+	* POST / with useraction="newrequest"
+	*
+	* Creates a brand-new transport request. Body carries the nested
+	* tm:request / tm:task with desc / type / target / owner.
+	*/
+	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 = {
+	/** GET / - List transports */
+	list: (params) => http$1.get("/sap/bc/adt/cts/transportrequests", {
+		query: params,
+		responses: { 200: transportmanagment },
+		headers: { Accept: "*/*" }
+	}),
+	/** GET /{trkorr} - Get single transport */
+	get: (trkorr) => http$1.get(`/sap/bc/adt/cts/transportrequests/${trkorr}`, {
+		responses: { 200: transportmanagmentSingle },
+		headers: { Accept: "application/vnd.sap.adt.transportorganizer.v1+xml" }
+	}),
+	/** POST / - Create new transport (response has root/request structure like single) */
+	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} - Action on transport (release, etc.) */
+	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} - Update transport */
+	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} - Delete transport */
+	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 request - development objects */
+	WORKBENCH: "K",
+	/** Customizing request - configuration */
+	CUSTOMIZING: "W",
+	/** Transport of copies */
+	TRANSPORT_OF_COPIES: "T",
+	/** Development/correction task */
+	DEVELOPMENT_CORRECTION: "S",
+	/** Repair task */
+	REPAIR: "R",
+	/** Unclassified task */
+	UNCLASSIFIED: "X",
+	/** Customizing task */
+	CUSTOMIZING_TASK: "Q",
+	/** Wildcard - all types */
+	ALL: "*"
+};
+/**
+* Transport status codes (TRSTATUS field) - for response parsing
+*/
+const TransportStatus = {
+	/** Modifiable - can be edited */
+	MODIFIABLE: "D",
+	/** Release started - in progress */
+	RELEASE_STARTED: "O",
+	/** Release in preparation */
+	RELEASE_IN_PREPARATION: "P",
+	/** Released - locked, cannot be edited */
+	RELEASED: "R",
+	/** Locked */
+	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 = { 
+/**
+* Search transports with filters
+*
+* GET /sap/bc/adt/cts/transports?_action=FIND&user=X&trfunction=*
+*
+* @example
+* // Find all modifiable workbench requests for current user
+* const result = await client.cts.transports.find({
+*   _action: 'FIND',
+*   user: 'PPLENKOV',
+*   trfunction: '*',
+* });
+*
+* @example
+* // Find with status filter
+* const result = await client.cts.transports.find({
+*   _action: 'FIND',
+*   user: '*',
+*   trfunction: 'K',
+*   requestStatus: 'D',  // Modifiable only
+* });
+*/
+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 /sap/bc/adt/cts/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 ATC worklist
+	*/
+	get: (worklistId, params) => http$1.get(`/sap/bc/adt/atc/worklists/${worklistId}`, {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "*/*" }
+	}),
+	/**
+	* GET ATC worklist
+	*/
+	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({
+	/**
+	* GET ATC results
+	*/
+	active: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	/**
+	* GET ATC results
+	*/
+	activeforsysid: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	/**
+	* GET ATC results
+	*/
+	user: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	/**
+	* GET ATC results
+	*/
+	central: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	/**
+	* GET ATC results
+	*/
+	centralforsysid: (params) => http$1.get("/sap/bc/adt/atc/results", {
+		query: params,
+		responses: { 200: atcworklist },
+		headers: { Accept: "application/xml" }
+	}),
+	/**
+	* GET ATC results
+	*/
+	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 /sap/bc/adt/atc/customizing
+*/
+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 /sap/bc/adt/atc/runs{?worklistId,clientWait}
+* Run ATC checks on objects specified in the request body
+*/
+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({ 
+/**
+* POST /sap/bc/adt/atc/worklists{?checkVariant}
+* Create a new ATC worklist
+*
+* NOTE: Not in SAP discovery - manually defined
+*/
+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/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 /sap/bc/adt/abapunit/testruns
+* Execute ABAP Unit test run with a runConfiguration body
+*
+* @returns runResult with programs, test classes, methods, and alerts
+*/
+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 /sap/bc/adt/oo/classrun/{classname}{?profilerId}
+* Execute a class implementing IF_OO_ADT_CLASSRUN
+*/
+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 = { 
+/**
+* Get Discovery Information
+*
+* Returns the ADT service discovery document in AtomPub format.
+* This document describes all available ADT services, workspaces, and collections.
+*
+* @endpoint GET /sap/bc/adt/discovery
+* @returns AtomPub service document with workspace and collection information
+*/
+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 packageCrudContract = 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)
+});
+/**
+* Typed package operations which are not CRUD-shaped. The discovery document
+* advertises this as `/sap/bc/adt/packages/$tree{?packagename,type}`.
+*/
+const packagesContract = contract({
+	...packageCrudContract,
+	tree: (params) => http$1.get("/sap/bc/adt/packages/$tree", {
+		query: params,
+		responses: { 200: packagesV1 },
+		headers: { Accept: "application/vnd.sap.adt.packages.v2+xml" }
+	})
+});
+
+//#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 = { 
+/**
+* Get or create an HTTP session
+* Also initializes CSRF token for subsequent requests
+*
+* Uses x-sap-security-session: create to establish a proper security session.
+* All subsequent operations should use x-sap-security-session: use to stay
+* within the same security session (required for lock/unlock).
+*
+* @returns Session information with CSRF token and links
+*/
+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({ 
+/**
+* Get system information
+*
+* @returns System information (systemID, client, userName, etc.)
+*/
+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 = { 
+/**
+* Quick search for ABAP objects
+*
+* @param query - Search query (supports wildcards like *)
+* @param maxResults - Maximum number of results (default: 50)
+* @param packageName - Filter by package name
+* @param objectType - Filter by object type (e.g., 'CLAS', 'INTF')
+* @returns Object references matching the search query (union of all adtcore element types)
+*
+* @example
+* // Search for classes starting with ZCL
+* const results = await client.repository.informationsystem.search.quickSearch({
+*   query: 'zcl*',
+*   maxResults: 10
+* });
+*
+* @example
+* // List all objects in a package
+* const results = await client.repository.informationsystem.search.quickSearch({
+*   query: '*',
+*   packageName: 'ZABAPGIT_EXAMPLES',
+*   maxResults: 200
+* });
+*/
+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+/, "");
+	}
+	const scopeElement = noProlog.replaceAll(/usagereferences:usageScopeResult/g, "usagereferences:scope");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<usagereferences:usageReferenceRequest xmlns:usagereferences="${USAGEREFS_NAMESPACE}">\n  <usagereferences:affectedObjects/>
+  ${scopeElement}\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/sourceversions.ts
+/**
+* ADT Repository source-history contracts.
+*
+* Both operations follow URIs supplied by SAP ADT responses. They deliberately
+* do not construct version paths from an object URI.
+*/
+const ADT_ORIGIN = "https://adt.invalid";
+const ADT_PATH = "/sap/bc/adt";
+const INVALID_URI_MESSAGE = "Expected an ADT-relative URI under /sap/bc/adt";
+/**
+* Guard an opaque ADT URI supplied by SAP before we turn it into an
+* authenticated request.  Other contracts which accept SAP-discovered URIs
+* share this boundary rather than reimplementing a slightly different URL
+* policy.
+*/
+function assertAdtRelativeUri(uri) {
+	let parsed;
+	try {
+		parsed = new URL(uri, ADT_ORIGIN);
+	} catch {
+		throw new TypeError(INVALID_URI_MESSAGE);
+	}
+	const isRootRelative = uri.startsWith("/") && !uri.startsWith("//");
+	const isAdtPath = parsed.pathname === ADT_PATH || parsed.pathname.startsWith(`${ADT_PATH}/`);
+	if (uri !== uri.trim() || !isRootRelative || parsed.origin !== ADT_ORIGIN || !isAdtPath || parsed.hash) throw new TypeError(INVALID_URI_MESSAGE);
+}
+const sourceversionsContract = contract({
+	list: (params) => {
+		assertAdtRelativeUri(params.versionsUri);
+		return http$1.get(params.versionsUri, {
+			responses: { 200: atomFeed },
+			headers: { Accept: "application/atom+xml;type=feed" }
+		});
+	},
+	get: (params) => {
+		assertAdtRelativeUri(params.sourceUri);
+		return http$1.get(params.sourceUri, {
+			responses: { 200: void 0 },
+			headers: { Accept: "text/plain" }
+		});
+	}
+});
+
+//#endregion
+//#region src/adt/repository/informationsystem/objectproperties.ts
+/**
+* ADT Repository Information System — object properties.
+*
+* SAP supplies the canonical object URI through quick search or object
+* metadata.  This endpoint enriches it with generic facets such as package
+* and application component; it does not construct an object-specific URL.
+*/
+const OBJECT_PROPERTIES_RESULT_MIME = "application/vnd.sap.adt.repository.objproperties.result.v1+xml";
+const objectPropertiesContract = { values: (params) => {
+	assertAdtRelativeUri(params.uri);
+	const facets = [...new Set(params.facets ?? [])].filter((facet) => facet.trim().length > 0);
+	return http$1.get("/sap/bc/adt/repository/informationsystem/objectproperties/values", {
+		query: {
+			uri: params.uri,
+			...facets.length > 0 ? { facet: facets } : {}
+		},
+		responses: { 200: objectProperties },
+		headers: { Accept: OBJECT_PROPERTIES_RESULT_MIME }
+	});
+} };
+
+//#endregion
+//#region src/adt/repository/informationsystem/index.ts
+const informationsystemContract = {
+	search: searchContract,
+	usageReferences: usageReferencesContract,
+	objectProperties: objectPropertiesContract
+};
+
+//#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,
+	sourceversions: sourceversionsContract
+};
+
+//#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 .../fmodules/{fmName} - Get function module metadata */
+	get: (_groupName, _fmName) => http$1.get(basePath$4 + "/${fmName}", {
+		responses: { 200: fmodules },
+		headers: { Accept: accept$2 }
+	}),
+	/** POST .../fmodules - Create function module */
+	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 .../fmodules/{fmName} - Update function module metadata */
+	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 .../fmodules/{fmName} - Delete function module */
+	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 } : {}
+		}
+	}),
+	/** POST .../fmodules/{fmName}?_action=LOCK - Lock function module */
+	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 } : {}
+		}
+	}),
+	/** POST .../fmodules/{fmName}?_action=UNLOCK - Unlock function module */
+	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 code operations */
+	source: { main: {
+		/** GET .../fmodules/{fmName}/source/main - Get source code */
+		get: (_groupName, _fmName) => http$1.get(basePath$4 + "/${fmName}/source/main", {
+			responses: { 200: void 0 },
+			headers: { Accept: "text/plain" }
+		}),
+		/** PUT .../fmodules/{fmName}/source/main - Update source code */
+		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 /sap/bc/adt/ddic/db/settings/{name} - Retrieve table settings XML */
+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.ddlSource+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.ddlSource+xml",
+	accept: "application/vnd.sap.adt.ddlSource+xml",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase()),
+	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.dclSource+xml
+* Object type: DCLS
+*/
+const dclSourcesContract = crud({
+	basePath: "/sap/bc/adt/acm/dcl/sources",
+	schema: dclSource,
+	contentType: "application/vnd.sap.adt.dclSource+xml",
+	accept: "application/vnd.sap.adt.dclSource+xml",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase()),
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/ddic/dcl/index.ts
+const dclContract = { sources: dclSourcesContract };
+
+//#endregion
+//#region src/adt/ddic/ddlx/sources.ts
+const ddlxSourcesContract = crud({
+	basePath: "/sap/bc/adt/ddic/ddlx/sources",
+	schema: ddlxSource,
+	contentType: "application/vnd.sap.adt.ddic.ddlx.v1+xml",
+	accept: "application/vnd.sap.adt.ddic.ddlx.v1+xml",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase()),
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/ddic/ddlx/index.ts
+const ddlxContract = { sources: ddlxSourcesContract };
+
+//#endregion
+//#region src/adt/ddic/dsfd/sources.ts
+const dsfdSourcesContract = crud({
+	basePath: "/sap/bc/adt/ddic/dsfd/sources",
+	schema: blueSource,
+	contentType: "application/vnd.sap.adt.blues.v1+xml",
+	accept: "application/vnd.sap.adt.blues.v1+xml",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase()),
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/ddic/dsfd/index.ts
+const dsfdContract = { sources: dsfdSourcesContract };
+
+//#endregion
+//#region src/adt/ddic/dsfi/index.ts
+const dsfiDefinitionSchema = {
+	_infer: void 0,
+	parse: (raw) => JSON.parse(raw),
+	build: (value) => JSON.stringify(value)
+};
+const baseContract$1 = crud({
+	basePath: "/sap/bc/adt/ddic/dsfi",
+	schema: blueSource,
+	contentType: "application/vnd.sap.adt.blues.v1+xml",
+	accept: "application/vnd.sap.adt.blues.v1+xml",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase())
+});
+const dsfiContract = {
+	...baseContract$1,
+	source: { main: { get: (name) => http.get(`/sap/bc/adt/ddic/dsfi/${encodeURIComponent(name.toLowerCase())}/source/main`, {
+		responses: { 200: dsfiDefinitionSchema },
+		headers: { Accept: "application/json" }
+	}) } }
+};
+
+//#endregion
+//#region src/adt/ddic/dteb/sources.ts
+const dtebSourcesContract = crud({
+	basePath: "/sap/bc/adt/ddic/dteb/sources",
+	schema: dtebSource,
+	contentType: "application/vnd.sap.adt.ddic.dteb.v1+xml",
+	accept: "application/vnd.sap.adt.ddic.dteb.v1+xml",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase()),
+	sources: ["main"]
+});
+
+//#endregion
+//#region src/adt/ddic/dteb/index.ts
+const dtebContract = { sources: dtebSourcesContract };
+
+//#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",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase()),
+	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,
+	ddlx: ddlxContract,
+	dsfd: dsfdContract,
+	dsfi: dsfiContract,
+	dteb: dtebContract,
+	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 for users by query string
+	*
+	* @param options.querystring - Search query (supports wildcards like *)
+	* @param options.maxcount - Maximum number of results
+	* @returns Atom feed with matching user entries (id = username, title = full name)
+	*
+	* @example
+	* const results = await client.system.users.search({ querystring: 'DEV*', maxcount: 10 });
+	*/
+	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 a specific user by username
+	*
+	* @param username - SAP username (e.g., 'DEVELOPER')
+	* @returns Atom feed with a single user entry
+	*
+	* @example
+	* const user = await client.system.users.get('DEVELOPER');
+	*/
+	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 all Personal Security Environments (identities).
+	*
+	* `GET /sap/bc/adt/system/security/pses`
+	*/
+	list: () => http$1.get("/sap/bc/adt/system/security/pses", {
+		responses: { 200: atomFeed },
+		headers: { Accept: "application/atom+xml;type=feed" }
+	}),
+	/**
+	* Get a single PSE identified by `{context}/{applic}`.
+	*
+	* `GET /sap/bc/adt/system/security/pses/{context}/{applic}`
+	*/
+	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" }
+	}),
+	/**
+	* List certificates inside a PSE.
+	*
+	* `GET /sap/bc/adt/system/security/pses/{context}/{applic}/certificates`
+	*/
+	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" }
+	}),
+	/**
+	* Fetch the PEM of a single certificate in a PSE.
+	*
+	* `GET /sap/bc/adt/system/security/pses/{context}/{applic}/certificates/{id}`
+	*/
+	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" }
+	}),
+	/**
+	* Upload a PEM certificate into a PSE. The body is the PEM text.
+	*
+	* `POST /sap/bc/adt/system/security/pses/{context}/{applic}/certificates`
+	*/
+	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"
+		}
+	}),
+	/**
+	* Delete a certificate from a PSE.
+	*
+	* `DELETE /sap/bc/adt/system/security/pses/{context}/{applic}/certificates/{id}`
+	*/
+	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 /sap/bc/adt/checkruns
+* Submit a checkObjectList and receive checkRunReports.
+*
+* Both request and response use the same `checkrun` schema (union discriminated
+* by the root element: `checkObjectList` for requests, `checkRunReports` for responses).
+*/
+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 /sap/bc/adt/activation{?method,preauditRequested}
+*
+* Submit an objectReferences body to activate the listed objects.
+* The `method` query param selects the action (default: "activate").
+* The response XML is not strictly typed here – callers may ignore it.
+*/
+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 /datapreview/freestyle - execute a free-style SQL query */
+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/request.ts
+const COVERAGE_NAMESPACE = "http://www.sap.com/adt/cov";
+const ADT_CORE_NAMESPACE = "http://www.sap.com/adt/core";
+const STATEMENTS_RELATION = "http://www.sap.com/adt/relations/runtime/traces/coverage/results/statements";
+const coverageXmlBody = {
+	parse: (value) => String(value),
+	build: (value) => value,
+	_infer: void 0
+};
+function escapeXmlAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function buildCoverageQuery(objectUris) {
+	const objectReferences = objectUris.map((uri) => `<adtcore:objectReference adtcore:uri="${escapeXmlAttribute(uri)}"/>`).join("\n");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<cov:query xmlns:cov="${COVERAGE_NAMESPACE}">
+<adtcore:objectSets xmlns:adtcore="${ADT_CORE_NAMESPACE}">
+<objectSet kind="inclusive">
+<adtcore:objectReferences>
+${objectReferences}
+</adtcore:objectReferences>
+</objectSet>
+</adtcore:objectSets>
+</cov:query>`;
+}
+function takeUnseenRecord(value, seenValues) {
+	if (!value || typeof value !== "object" || seenValues.has(value)) return;
+	seenValues.add(value);
+	return value;
+}
+function takeStatementUri(record, seenUris) {
+	const { rel, href } = record;
+	if (rel !== STATEMENTS_RELATION || typeof href !== "string" || seenUris.has(href)) return;
+	seenUris.add(href);
+	return href;
+}
+function enqueueChildObjects(record, queue) {
+	for (const child of Object.values(record)) {
+		if (Array.isArray(child)) {
+			queue.push(...child);
+			continue;
+		}
+		if (child && typeof child === "object") queue.push(child);
+	}
+}
+function extractCoverageStatementUris(value) {
+	const statementUris = [];
+	const seenUris = /* @__PURE__ */ new Set();
+	const seenValues = /* @__PURE__ */ new Set();
+	const queue = [value];
+	while (queue.length > 0) {
+		const record = takeUnseenRecord(queue.shift(), seenValues);
+		if (!record) continue;
+		const statementUri = takeStatementUri(record, seenUris);
+		if (statementUri) statementUris.push(statementUri);
+		enqueueChildObjects(record, queue);
+	}
+	return statementUris;
+}
+function buildStatementsBulkRequest(statementUris) {
+	const requests = statementUris.map((uri) => `<statementsRequest get="${escapeXmlAttribute(uri)}"/>`).join("\n");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<cov:statementsBulkRequest xmlns:cov="${COVERAGE_NAMESPACE}">
+${requests}
+</cov:statementsBulkRequest>`;
+}
+
+//#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
+* Accept:       application/xml
+*/
+const XML_CONTENT_TYPE$1 = "application/xml";
+const measurements = contract({ 
+/**
+* POST /sap/bc/adt/runtime/traces/coverage/measurements/{identifier}
+*   ?withAdditionalTypeInfo=true
+*
+* Returns the coverage tree rooted at ADT_ROOT_NODE with coverage
+* totals (branch/procedure/statement) for each object reference.
+*/
+post: (identifier) => http$1.post(`/sap/bc/adt/runtime/traces/coverage/measurements/${identifier}`, {
+	query: { withAdditionalTypeInfo: true },
+	body: coverageXmlBody,
+	responses: { 200: acoverageResult },
+	headers: {
+		Accept: XML_CONTENT_TYPE$1,
+		"Content-Type": "application/xml"
+	}
+}) });
+
+//#endregion
+//#region src/adt/runtime/traces/coverage/statements.ts
+/**
+* /sap/bc/adt/runtime/traces/coverage/results/{id}/statements
+*
+* POST returns the cov:statementsBulkResponse with per-method statement
+* / branch / procedure coverage details.
+*
+* Content-Type: application/xml
+* Accept:       application/xml
+*/
+const XML_CONTENT_TYPE = "application/xml";
+const statements = contract({ 
+/**
+* POST /sap/bc/adt/runtime/traces/coverage/results/{identifier}/statements
+*/
+post: (identifier) => http$1.post(`/sap/bc/adt/runtime/traces/coverage/results/${identifier}/statements`, {
+	body: coverageXmlBody,
+	responses: { 200: acoverageStatements },
+	headers: {
+		Accept: XML_CONTENT_TYPE,
+		"Content-Type": "application/xml"
+	}
+}) });
+
+//#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",
+	nameTransform: (name) => encodeURIComponent(name.toLowerCase()),
+	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.v2+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) => encodeURIComponent(n.toLowerCase());
+const baseContract = crud({
+	basePath,
+	schema: servicebinding,
+	contentType: "application/vnd.sap.adt.businessservices.servicebinding.v2+xml",
+	accept: "application/vnd.sap.adt.businessservices.servicebinding.v2+xml",
+	nameTransform
+});
+/**
+* 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/vit/wb/objectproperties.ts
+/**
+* ADT vit/wb — Basic Object Properties (classic Workbench metadata).
+*
+* Endpoint template (from ADT discovery):
+*   GET /sap/bc/adt/vit/wb/object_type/{type}/object_name/{name}
+*
+* Accept: application/vnd.sap.adt.basic.object.properties+xml
+* Response: adtcore:mainObject
+*
+* Classic BAdI uses vit types:
+*   sxsdxd — BAdI definition  (repository type SXSD/XD)
+*   sxcixi — BAdI implementation (repository type SXCI/XI)
+*/
+const BASIC_OBJECT_PROPERTIES_MIME = "application/vnd.sap.adt.basic.object.properties+xml";
+/** vit/wb object_type segment for classic BAdI definitions. */
+const CLASSIC_BADI_DEFINITION_VIT_TYPE = "sxsdxd";
+/** vit/wb object_type segment for classic BAdI implementations. */
+const CLASSIC_BADI_IMPLEMENTATION_VIT_TYPE = "sxcixi";
+function objectPropertiesPath(vitType, objectName) {
+	const normalizedType = vitType.trim().toLowerCase();
+	const normalizedName = objectName.trim().toLowerCase();
+	return `/sap/bc/adt/vit/wb/object_type/${encodeURIComponent(normalizedType)}/object_name/${encodeURIComponent(normalizedName)}`;
+}
+function getByVitType(vitType) {
+	return (objectName) => http$1.get(objectPropertiesPath(vitType, objectName), {
+		responses: { 200: adtcore },
+		headers: { Accept: BASIC_OBJECT_PROPERTIES_MIME }
+	});
+}
+/**
+* /sap/bc/adt/vit/wb/object_type/{type}/object_name/{name}
+*/
+const vitWbObjectPropertiesContract = contract({
+	/** Generic read for any vit/wb object_type segment. */
+	get: (params) => http$1.get(objectPropertiesPath(params.vitType, params.objectName), {
+		responses: { 200: adtcore },
+		headers: { Accept: BASIC_OBJECT_PROPERTIES_MIME }
+	}),
+	/** Classic BAdI definition (SXSD/XD). */
+	getDefinition: getByVitType(CLASSIC_BADI_DEFINITION_VIT_TYPE),
+	/** Classic BAdI implementation (SXCI/XI). */
+	getImplementation: getByVitType(CLASSIC_BADI_IMPLEMENTATION_VIT_TYPE)
+});
+
+//#endregion
+//#region src/adt/vit/index.ts
+const vitContract = { wb: { objectProperties: vitWbObjectPropertiesContract } };
+
+//#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,
+	vit: vitContract
+};
+
+//#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 { coverageContract as $, usageReferencesContract as $t, gctsBranchesSchema as A, structuresContract as At, gctsPullSchema as B, objectstructureContract as Bt, enhancementsContract as C, dclContract as Ct, boContract as D, tabletypesContract as Dt, bindingsContract as E, ddlSourcesContract as Et, gctsCreateBranchResponseSchema as F, functionGroupsContract as Ft, runtimeContract as G, sourceversionsContract as Gt, gctsRepositorySchema as H, OBJECT_PROPERTIES_RESULT_MIME as Ht, gctsCreateRepositoryBodySchema as I, programsModuleContract as It, profile as J, SEARCH_REQUEST_MIME as Jt, dumps as K, SCOPE_REQUEST_MIME as Kt, gctsGenericOkSchema as L, includesContract as Lt, gctsCommitResponseSchema as M, domainsContract as Mt, gctsConfigSchema as N, functionsContract as Nt, behaviordefinitionsContract as O, tablesettingsContract as Ot, gctsCreateBranchBodySchema as P, functionModulesContract as Pt, runtimeTraceListSchema as Q, buildUsageScopeRequestXml as Qt, gctsLogSchema as R, programsContract as Rt, normalizeOdataFeed as S, ddlxSourcesContract as St, businessservicesContract as T, ddlContract as Tt, gctsSetConfigBodySchema as U, objectPropertiesContract as Ut, gctsRepositoriesSchema as V, informationsystemContract as Vt, gctsSetItemBodySchema as W, assertAdtRelativeUri as Wt, runtimeDumpListSchema as X, USAGEREFS_NAMESPACE as Xt, runtimeDumpDetailSchema as Y, SEARCH_RESPONSE_MIME as Yt, runtimeTraceDetailSchema as Z, buildUsageReferenceRequestXml as Zt, flpGroupListSchema as _, TransportStatus as _n, dtebSourcesContract as _t, vitContract as a, packagesContract as an, extractCoverageStatementUris as at, flpTileSchema as b, crud as bn, dsfdSourcesContract as bt, CLASSIC_BADI_IMPLEMENTATION_VIT_TYPE as c, classrunContract as cn, activationContract as ct, completion as d, aunitContract as dn, psesContract as dt, searchContract as en, statements as et, completionRequestSchema as f, atcContract as fn, usersContract as ft, flpCatalogSchema as g, TransportFunction as gn, dtebContract as gt, flpCatalogListSchema as h, ctsContract as hn, srvdSourcesContract as ht, adtContract as i, sessionsContract as in, coverageXmlBody as it, gctsCommitBodySchema as j, dataelementsContract as jt, gctsContract as k, tablesContract as kt, vitWbObjectPropertiesContract as l, interfacesContract as ln, checkrunsContract as lt, flpContract as m, worklistsContract as mn, srvdContract as mt, createAdtClient as n, httpContract as nn, buildCoverageQuery as nt, BASIC_OBJECT_PROPERTIES_MIME as o, discoveryContract as on, datapreviewContract as ot, completionResponseSchema as p, resultsContract as pn, ddicContract as pt, tracesContract as q, SCOPE_RESPONSE_MIME as qt, http$1 as r, systeminformationContract as rn, buildStatementsBulkRequest as rt, CLASSIC_BADI_DEFINITION_VIT_TYPE as s, ooContract as sn, freestyle as st, contract as t, coreContract as tn, measurements as tt, codeassistanceContract as u, classesContract as un, systemContract as ut, flpGroupSchema as v, normalizeTransportFindResponse as vn, dsfiContract as vt, enhoxhhContract as w, dclSourcesContract as wt, normalizeOdataEntity as x, repo as xn, ddlxContract as xt, flpTileListSchema as y, transports as yn, dsfdContract as yt, gctsObjectsSchema as z, repositoryContract as zt };
+//# sourceMappingURL=base-CJ5t6dbP.mjs.map