@abapify/adk 0.4.0 → 0.4.1

package/dist/index.d.mts

@@ -0,0 +1,2899 @@
+import { LockEntry, LockHandle, LockHandle as LockHandle$1, LockService, LockService as LockService$1, LockStore, LockStore as LockRegistry, LockStore as LockStore$1, createLockService } from "@abapify/adt-locks";
+import { AdtClient, AdtClient as AdtClient$1, ClassResponse as ClassResponse$1, DataElementResponse, DomainResponse, FunctionGroupResponse as FunctionGroupResponse$1, FunctionModuleResponse as FunctionModuleResponse$1, IncludeResponse as IncludeResponse$1, InterfaceResponse as InterfaceResponse$1, PackageResponse as PackageResponse$1, ProgramResponse as ProgramResponse$1, TableResponse, TableTypeResponse, TransportGetResponse } from "@abapify/adt-client";
+
+//#region src/base/adt.d.ts
+/**
+ * Extract the abapClass variant from ClassResponse union
+ * ClassResponse = { abapClass: ... } | { abapClassInclude: ... }
+ * ADK Class objects only use the abapClass variant
+ */
+type ClassResponse = Extract<ClassResponse$1, {
+  abapClass: unknown;
+}>;
+/**
+ * Extract the abapInterface variant from InterfaceResponse union
+ */
+type InterfaceResponse = Extract<InterfaceResponse$1, {
+  abapInterface: unknown;
+}>;
+/**
+ * Extract the package variant from PackageResponse union
+ * PackageResponse = { package: ... } | { packageTree: ... }
+ * ADK Package objects only use the package variant
+ */
+type PackageResponse = Extract<PackageResponse$1, {
+  package: unknown;
+}>;
+/**
+ * Program response type - single root element (no union needed)
+ */
+type ProgramResponse = ProgramResponse$1;
+/**
+ * Include response type - single root element (no union needed)
+ */
+type IncludeResponse = IncludeResponse$1;
+/**
+ * Function group response type - single root element (no union needed)
+ */
+type FunctionGroupResponse = FunctionGroupResponse$1;
+/**
+ * Function module response type - single root element (no union needed)
+ */
+type FunctionModuleResponse = FunctionModuleResponse$1;
+/**
+ * ADT REST contracts accessible via client.adt.*
+ *
+ * This is the typed contract layer from adt-client.
+ * Example: client.adt.oo.classes.get('ZCL_MY_CLASS')
+ */
+type AdtContracts = AdtClient$1['adt'];
+/**
+ * ADK Contract interface
+ *
+ * Proxy to adt-client contracts.
+ * Provides typed access to ADT REST endpoints.
+ */
+interface AdkContract {
+  /** OO contracts (classes, interfaces) */
+  readonly oo: AdtContracts['oo'];
+  /** Packages contract */
+  readonly packages: AdtContracts['packages'];
+  /** CTS contracts (transports) */
+  readonly cts: AdtContracts['cts'];
+  /** Core contracts (discovery, sessions) */
+  readonly core: AdtContracts['core'];
+  /** Repository contracts (search) */
+  readonly repository: AdtContracts['repository'];
+  /** Programs contracts */
+  readonly programs: AdtContracts['programs'];
+  /** Functions contracts (function groups) */
+  readonly functions: AdtContracts['functions'];
+  /** DDIC contracts (domains, data elements, structures, tables, table types) */
+  readonly ddic: AdtContracts['ddic'];
+  /** BO contracts (behavior definitions) */
+  readonly bo: AdtContracts['bo'];
+}
+/**
+ * Create ADK contract from ADT client
+ *
+ * @param client - ADT client instance from createAdtClient()
+ * @returns ADK contract proxy
+ */
+declare function createAdkContract(client: AdtClient$1): AdkContract;
+//#endregion
+//#region src/base/context.d.ts
+/**
+ * Context provided to all ADK objects
+ *
+ * Provides direct access to ADT client.
+ * Objects use client.adt.* for contracts and client.services.* for services.
+ *
+ * @example
+ * // In AdkClass.load():
+ * const data = await this.ctx.client.adt.oo.classes.get(this.name);
+ *
+ * // In AdkTransport:
+ * const transport = await this.ctx.client.services.transports.get(this.id);
+ */
+interface AdkContext {
+  /**
+   * ADT client instance
+   *
+   * Provides:
+   * - client.adt.* - Low-level REST contracts
+   * - client.services.* - High-level service APIs
+   * - client.fetch() - Raw HTTP for edge cases
+   */
+  readonly client: AdtClient;
+  /**
+   * Optional lock store for persisting lock handles to disk.
+   *
+   * When provided, lock()/unlock() will register/deregister entries
+   * so that stale locks can be recovered after process crashes.
+   * If not provided, locks are only held in memory (default behavior).
+   */
+  readonly lockStore?: LockStore$1;
+  /**
+   * Lock service for centralized lock/unlock operations.
+   *
+   * Provides HTTP lock/unlock + automatic store registration.
+   * Used by ADK models, CLI commands, and export logic so that
+   * every lock operation is tracked in a single store.
+   */
+  readonly lockService?: LockService$1;
+}
+//#endregion
+//#region src/base/model.d.ts
+/**
+ * Save mode for create/update operations
+ * - 'update': PUT to existing object (default, fails if doesn't exist)
+ * - 'create': POST to create new object (skips POST if already exists, then updates)
+ * - 'upsert': Try PUT first, fall back to POST if 404
+ */
+type SaveMode = 'update' | 'create' | 'upsert';
+/**
+ * Options for save operations
+ */
+interface SaveOptions {
+  /** Transport request for the change */
+  transport?: string;
+  /** Save as inactive (default: false) */
+  inactive?: boolean;
+  /** Save mode: 'update' (default), 'create', or 'upsert' */
+  mode?: SaveMode;
+}
+/**
+ * Result of bulk activation
+ */
+interface ActivationResult {
+  /** Number of successfully activated objects */
+  success: number;
+  /** Number of objects that failed activation */
+  failed: number;
+  /** Activation messages (errors, warnings) */
+  messages: string[];
+  /** Raw response from SAP (for debugging) */
+  response?: string;
+}
+/**
+ * Atom link (from atom:link element)
+ * Used for HATEOAS-style navigation in ADT responses
+ */
+interface AtomLink {
+  href: string;
+  rel?: string;
+  type?: string;
+  title?: string;
+  etag?: string;
+}
+/**
+ * ADT object reference (adtcore:objectReference)
+ */
+interface AdtObjectReference {
+  uri?: string;
+  name?: string;
+  type?: string;
+  description?: string;
+  packageName?: string;
+}
+/**
+ * Base data contract for all ADK objects
+ * Matches XSD AdtObject type attributes and elements
+ */
+interface AdkObjectData {
+  name: string;
+  type: string;
+  description?: string;
+  changedBy?: string;
+  changedAt?: string | Date;
+  createdBy?: string;
+  createdAt?: string | Date;
+  version?: string;
+  language?: string;
+  descriptionTextLimit?: number;
+  links?: AtomLink[];
+  containerRef?: AdtObjectReference;
+}
+/**
+ * Main object data contract (extends AdtObject)
+ * Matches XSD AdtMainObject type
+ */
+interface AdkMainObjectData extends AdkObjectData {
+  packageRef?: AdtObjectReference;
+  masterSystem?: string;
+  masterLanguage?: string;
+  responsible?: string;
+  abapLanguageVersion?: string;
+}
+/**
+ * Base class for all ADK objects
+ *
+ * All ADK objects (AdkPackage, AdkTransportRequest, etc.) extend this.
+ * Supports deferred loading - create with just a name, then call load().
+ *
+ * Note: Uses loose type constraint for D to allow schema-inferred types
+ * from contracts which may have different shapes. The getters safely
+ * handle missing properties with defaults.
+ *
+ * @typeParam K - The object kind (from AdkKind)
+ * @typeParam D - The internal data type (typically schema-inferred from contract)
+ */
+declare abstract class AdkObject<K extends AdkKind = AdkKind, D = any> {
+  /** Object kind identifier */
+  abstract readonly kind: K;
+  /**
+   * ADT object URI - base path for all operations.
+   * Example: `/sap/bc/adt/oo/classes/zcl_my_class`
+   */
+  abstract get objectUri(): string;
+  /**
+   * ADT collection URI - base path for creating new objects.
+   * Example: `/sap/bc/adt/oo/classes`
+   * Default: derived from objectUri by removing the object name
+   */
+  get collectionUri(): string;
+  protected ctx: AdkContext;
+  /** Public access to the ADT client for plugins and external code */
+  get client(): AdtClient;
+  protected _data?: D;
+  protected _name: string;
+  protected cache: Map<string, unknown>;
+  protected dirty: Set<string>;
+  protected _lockHandle?: LockHandle$1;
+  /** Set by save() when all pending changes are identical to SAP state */
+  _unchanged: boolean;
+  /**
+   * Create ADK object
+   * @param ctx - ADK context
+   * @param dataOrName - Full data object OR just the object name for deferred loading
+   */
+  constructor(ctx: AdkContext, dataOrName: D | string);
+  /**
+   * Adopt a richer context (merge services into existing context).
+   *
+   * Used by AdkObjectSet to propagate lockService / lockStore
+   * to objects created by plugins that only have { client }.
+   * Keeps the original client reference intact.
+   */
+  adoptContext(ctx: AdkContext): void;
+  /**
+   * Load object data from SAP
+   *
+   * Default implementation uses crudContract.get() and unwraps with wrapperKey.
+   * Objects without crudContract must override this.
+   *
+   * @returns this (for chaining)
+   */
+  load(): Promise<this>;
+  /** Whether data has been loaded */
+  get isLoaded(): boolean;
+  /**
+   * Get data - auto-loads if not already loaded
+   * @returns Promise that resolves to the data
+   */
+  data(): Promise<D>;
+  /**
+   * Get data synchronously - throws if not loaded
+   * Use when you know data is already loaded
+   */
+  get dataSync(): D;
+  /** Set data (for subclasses to use after loading) */
+  protected setData(data: D): void;
+  /** Helper to access data with AdkObjectData properties */
+  private get coreData();
+  /** ADT object name (adtcore:name) - available even before load() */
+  get name(): string;
+  /** ADT object type (adtcore:type, e.g. 'RQRQ', 'DEVC/K') - requires load() */
+  get type(): string;
+  /** Description text (adtcore:description) */
+  get description(): string;
+  /** Version state (adtcore:version) - active, inactive, etc. */
+  get version(): string;
+  /** Current language (adtcore:language) */
+  get language(): string;
+  /** User who last modified (adtcore:changedBy) */
+  get changedBy(): string;
+  /** Last modification timestamp (adtcore:changedAt) */
+  get changedAt(): Date;
+  /** User who created (adtcore:createdBy) */
+  get createdBy(): string;
+  /** Creation timestamp (adtcore:createdAt) */
+  get createdAt(): Date;
+  /** All atom:link elements */
+  get links(): AtomLink[];
+  /** Find link by rel attribute */
+  getLink(rel: string): AtomLink | undefined;
+  /** Get link href by rel, or undefined */
+  getLinkHref(rel: string): string | undefined;
+  /** Container reference (adtcore:containerRef) */
+  get containerRef(): AdtObjectReference | undefined;
+  /** Check if object is currently locked */
+  get isLocked(): boolean;
+  /** Get current lock handle */
+  get lockHandle(): LockHandle$1 | undefined;
+  /**
+   * Lock the object for modification
+   *
+   * Delegates to the lock service (single lock mechanism).
+   *
+   * The lock response contains:
+   * - LOCK_HANDLE: Required for subsequent PUT/unlock operations
+   * - CORRNR: Transport request assigned to this object (use for PUT if no explicit transport)
+   * - CORRUSER: User who owns the transport
+   *
+   * @param transport - Optional transport request to use for locking.
+   *                    Required when object is already in a transport.
+   */
+  lock(transport?: string): Promise<LockHandle$1>;
+  /**
+   * Unlock the object
+   *
+   * Delegates to the lock service (single lock mechanism).
+   */
+  unlock(): Promise<void>;
+  /**
+   * Set lock handle (for subclasses that need custom lock logic)
+   */
+  protected setLockHandle(handle: LockHandle$1 | undefined): void;
+  /**
+   * Save the object to SAP
+   *
+   * Generic implementation that handles:
+   * - Lock/unlock lifecycle
+   * - Mode switching (create/update/upsert)
+   * - Error handling
+   *
+   * Subclasses implement `saveViaContract()` to provide the typed contract call.
+   *
+   * Modes:
+   * - 'update' (default): PUT to existing object
+   * - 'create': POST skeleton, then lock → PUT/source → unlock (Eclipse ADT pattern)
+   * - 'upsert': Check existence, create if needed, then update
+   *
+   * @param options - Save options
+   * @returns this (for chaining)
+   */
+  save(options?: SaveOptions): Promise<this>;
+  /**
+   * Wrapper key for the data in contract requests/responses
+   *
+   * Contracts wrap data like { abapClass: ... } or { abapInterface: ... }.
+   * Subclasses that support save override this.
+   */
+  protected get wrapperKey(): string | undefined;
+  /**
+   * CRUD contract for this object type
+   *
+   * Subclasses that support save override this to return their contract.
+   */
+  protected get crudContract(): any;
+  /**
+   * Execute the typed contract call for save
+   *
+   * Generic implementation using wrapperKey and crudContract.
+   * Objects that don't support save leave wrapperKey/crudContract undefined.
+   *
+   * For 'create' mode: POSTs skeleton data (minimal fields).
+   * For 'update' mode: PUTs full data (all fields except abapLanguageVersion).
+   *
+   * @param mode - 'create' (POST skeleton) or 'update' (PUT full)
+   * @param options - Contract options (transport, lockHandle)
+   */
+  protected saveViaContract(mode: 'create' | 'update', options: {
+    transport?: string;
+    lockHandle?: string;
+  }): Promise<void>;
+  /**
+   * Get skeleton data for object creation (POST).
+   *
+   * Returns only the minimal fields needed to create the object on SAP.
+   * SAP creates the object structure (includes, etc.) from these fields.
+   * Full metadata and source code are sent via PUT in the update step.
+   *
+   * Override in subclasses that need different skeleton fields.
+   */
+  protected getSkeletonData(): Promise<Record<string, unknown>>;
+  /**
+   * Check if the object exists on the SAP system.
+   *
+   * Used by upsert mode to decide between update and create paths upfront.
+   * On BTP, locking a non-existent DDIC object creates a draft that persists
+   * even after unlock, blocking subsequent POST (create) attempts. Checking
+   * existence first with GET avoids this problem entirely.
+   */
+  protected checkObjectExists(): Promise<boolean>;
+  /**
+   * Check if error is a 404 Not Found
+   */
+  protected isNotFoundError(e: unknown): boolean;
+  /**
+   * Upsert fallback: try POST (create), treat 422 "already exists" as unchanged.
+   * Extracted to avoid duplication in lock-catch and saveViaContract-catch paths.
+   */
+  private fallbackToCreate;
+  /**
+   * Check if error suggests the object doesn't exist or the operation
+   * is not supported for the current state.
+   *
+   * Some SAP DDIC endpoints (TABL, TTYP) return 405 Method Not Allowed
+   * instead of 404 when attempting to lock or PUT a non-existent object.
+   * In upsert mode, both should trigger a fallback to POST (create).
+   */
+  protected shouldFallbackToCreate(e: unknown): boolean;
+  /**
+   * Check if error is a 422 "already exists" from a POST create attempt
+   */
+  protected isAlreadyExistsError(e: unknown): boolean;
+  /**
+   * Check if object has pending sources to save
+   * Subclasses with source code (classes, interfaces) override this
+   */
+  protected hasPendingSources(): boolean;
+  /**
+   * Normalize source code for comparison.
+   * Trims trailing whitespace/newlines so minor formatting differences
+   * don't trigger unnecessary saves.
+   */
+  protected normalizeSource(source: string): string;
+  /**
+   * Check if pending sources are unchanged vs SAP (pre-lock comparison).
+   * Sets _unchanged = true if nothing needs saving.
+   *
+   * Default handles single-source objects (_pendingSource) by fetching
+   * GET {objectUri}/source/main and comparing.
+   * AdkClass overrides this for multi-include logic.
+   */
+  protected checkPendingSourcesUnchanged(): Promise<void>;
+  /**
+   * Check if metadata-only objects are unchanged on SAP.
+   *
+   * For objects without source code (DDIC types like DOMA, DTEL, TABL, TTYP),
+   * fetches the current SAP state and compares only the fields present in
+   * the local data. SAP returns extra volatile fields (timestamps, links,
+   * version, etc.) that are ignored — only semantic fields matter.
+   */
+  protected checkMetadataUnchanged(): Promise<void>;
+  /**
+   * Refresh cached ETags after acquiring a lock.
+   *
+   * SAP changes the object's internal version when a lock is acquired,
+   * which invalidates any cached ETags. Without refreshing, the next
+   * PUT sends a stale If-Match header and SAP returns HTTP 412.
+   *
+   * For objects with pending sources: re-GET {objectUri}/source/main
+   * For metadata-only objects: re-GET via crudContract.get()
+   *
+   * Subclasses with multiple source endpoints (e.g., AdkClass with includes)
+   * should override this to refresh all relevant endpoints.
+   */
+  protected refreshETagsAfterLock(): Promise<void>;
+  /**
+   * Save pending sources to SAP.
+   *
+   * Default handles single-source objects (_pendingSource) by PUTting
+   * to {objectUri}/source/main.
+   * AdkClass overrides this for multi-include logic.
+   */
+  protected savePendingSources(options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  /**
+   * Set source content for a source-based object
+   *
+   * Generic implementation for objects with source code (classes, includes, etc.)
+   * Subclasses should override if they need custom source handling.
+   *
+   * @param sourcePath - Relative path to source (e.g., '/source/main')
+   * @param content - Source code content
+   * @param options - Save options
+   */
+  setSource(sourcePath: string, content: string, options?: SaveOptions): Promise<void>;
+  /**
+   * Activate this object
+   *
+   * Activates a single object. For bulk activation of multiple objects,
+   * use `AdkObjectSet.activateAll()`.
+   *
+   * @returns this (for chaining)
+   */
+  activate(): Promise<this>;
+  /** Lazy load a segment (async) - fetches only once, then cached */
+  protected lazy<T>(key: string, loader: () => Promise<T>): Promise<T>;
+  /** Lazy compute a segment (sync) - computes only once, then cached */
+  protected cached<T>(key: string, compute: () => T): T;
+  /** Set a cached value directly (for local/generated data) */
+  protected set<T>(key: string, value: T): void;
+  /** Mark a segment as dirty (modified locally) */
+  protected markDirty(key: string): void;
+  /** Check if any segment (or specific segment) is dirty */
+  isDirty(segment?: string): boolean;
+  /** Clear cache for a segment (force reload on next access) */
+  protected invalidate(key: string): void;
+  /**
+   * Fetch a text resource from an ADT endpoint.
+   * Delegates to the underlying ADT client's fetch.
+   *
+   * @param url - ADT endpoint path (e.g., '/sap/bc/adt/ddic/dataelements/spras')
+   * @param headers - Optional HTTP headers (defaults to no Accept header, letting server choose)
+   * @returns Response content as text, or undefined if 404
+   */
+  fetchText(url: string, headers?: Record<string, string>): Promise<string | undefined>;
+}
+/**
+ * Base class for main development objects (AdtMainObject)
+ *
+ * Extends AdkObject with package reference, responsible user, and master language.
+ * Used for repository objects like classes, interfaces, packages, etc.
+ *
+ * Note: Uses type assertions internally because schema-inferred types from
+ * contracts may have different shapes than AdkMainObjectData. The getters
+ * safely handle missing properties with defaults.
+ *
+ * @typeParam K - The object kind (from AdkKind)
+ * @typeParam D - The internal data type (typically schema-inferred from contract)
+ */
+declare abstract class AdkMainObject<K extends AdkKind = AdkKind, D = any> extends AdkObject<K, D> {
+  private get mainData();
+  /** Package reference (adtcore:packageRef) */
+  get packageRef(): AdtObjectReference | undefined;
+  /** Package name (convenience getter) */
+  get package(): string;
+  /** Master system (adtcore:masterSystem) */
+  get masterSystem(): string;
+  /** Master language (adtcore:masterLanguage) */
+  get masterLanguage(): string;
+  /** Responsible user (adtcore:responsible) */
+  get responsible(): string;
+  /** ABAP language version (adtcore:abapLanguageVersion) */
+  get abapLanguageVersion(): string;
+  /**
+   * Save main source code to SAP.
+   * Requires the object to be locked before calling.
+   * Subclasses may override to add additional behavior (e.g. cache invalidation).
+   */
+  saveMainSource(source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/clas/clas.types.d.ts
+/**
+ * Class category (class:category attribute)
+ */
+type ClassCategory = 'generalObjectType' | 'exceptionClass' | 'testClass' | 'exitClass' | 'areaClass' | 'factoryClass' | 'persistentClass' | 'bspClass' | 'staticTypedLcpClass' | 'behaviorPool' | 'rfcProxyClass' | 'entityEventHandler' | 'communicationConnectionClass' | 'others';
+/**
+ * Class include type (class:includeType attribute)
+ */
+type ClassIncludeType = 'main' | 'definitions' | 'implementations' | 'macros' | 'testclasses' | 'localtypes';
+/**
+ * Class visibility (class:visibility attribute)
+ */
+type ClassVisibility = 'public' | 'protected' | 'private';
+/**
+ * Class include section
+ */
+interface ClassInclude {
+  readonly includeType: ClassIncludeType;
+  readonly sourceUri: string;
+  readonly name: string;
+  readonly type: string;
+  readonly version: string;
+  readonly changedAt: Date;
+  readonly createdAt: Date;
+  readonly changedBy: string;
+  readonly createdBy: string;
+}
+/**
+ * ABAP Class interface
+ *
+ * Plugins work with this interface - implementation is internal.
+ * Mirrors ADT class:abapClass structure.
+ */
+interface AbapClass extends AbapObject {
+  readonly kind: 'Class';
+  readonly responsible: string;
+  readonly masterLanguage: string;
+  readonly language: string;
+  readonly version: string;
+  readonly createdAt: Date;
+  readonly createdBy: string;
+  readonly changedAt: Date;
+  readonly changedBy: string;
+  readonly category: ClassCategory;
+  readonly final: boolean;
+  readonly abstract: boolean;
+  readonly visibility: ClassVisibility;
+  readonly sharedMemoryEnabled: boolean;
+  readonly modeled: boolean;
+  readonly fixPointArithmetic: boolean;
+  readonly activeUnicodeCheck: boolean;
+  readonly superClassRef?: AdtObjectReference;
+  readonly messageClassRef?: AdtObjectReference;
+  readonly packageRef?: AdtObjectReference;
+  readonly includes: ClassInclude[];
+  /**
+   * Get main source code (global definitions + implementations)
+   */
+  getMainSource(): Promise<string>;
+  /**
+   * Get source code for a specific include
+   */
+  getIncludeSource(includeType: ClassIncludeType): Promise<string>;
+  /**
+   * Get definitions include source
+   */
+  getDefinitions(): Promise<string>;
+  /**
+   * Get implementations include source
+   */
+  getImplementations(): Promise<string>;
+  /**
+   * Get test classes source
+   */
+  getTestClasses(): Promise<string>;
+}
+//#endregion
+//#region src/objects/repository/clas/clas.model.d.ts
+/**
+ * Class data type - imported from contract
+ *
+ * The schema wraps everything in an 'abapClass' element, so we unwrap it here
+ * to provide a flat structure for ADK consumers.
+ */
+type ClassXml = ClassResponse['abapClass'];
+/**
+ * ADK Class object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Access class-specific properties via `data`:
+ * - data.category, data.final, data.abstract, data.visibility
+ * - data.sharedMemoryEnabled, data.modeled, data.fixPointArithmetic
+ * - data.superClassRef, data.messageClassRef, data.include
+ */
+declare class AdkClass extends AdkMainObject<typeof Class, ClassXml> {
+  static readonly kind: "Class";
+  readonly kind: "Class";
+  get objectUri(): string;
+  getMainSource(): Promise<string>;
+  getIncludeSource(includeType: ClassIncludeType): Promise<string>;
+  getDefinitions(): Promise<string>;
+  getImplementations(): Promise<string>;
+  getTestClasses(): Promise<string>;
+  /**
+   * Save main source code
+   * Requires object to be locked first
+   */
+  saveMainSource(source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  /**
+   * Save include source code
+   * Requires object to be locked first
+   */
+  saveIncludeSource(includeType: ClassIncludeType, source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  /**
+   * Save all pending sources (set via _pendingSources)
+   * Used by export workflow after deserialization from abapGit
+   * Overrides base class method
+   *
+   * Note: unchanged detection is handled by checkPendingSourcesUnchanged()
+   * which runs BEFORE lock acquisition. By the time we reach here,
+   * at least one source differs — save them all.
+   */
+  protected savePendingSources(options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  /**
+   * Pre-lock comparison: check if all pending sources match SAP
+   * If identical, sets _unchanged = true so save() skips locking and PUT
+   */
+  protected checkPendingSourcesUnchanged(): Promise<void>;
+  /**
+   * Check if object has pending sources to save
+   * Overrides base class method
+   */
+  protected hasPendingSources(): boolean;
+  /**
+   * Refresh cached ETags for all pending source endpoints after locking.
+   * Classes have multiple source URLs (main + includes) that all need fresh ETags.
+   */
+  protected refreshETagsAfterLock(): Promise<void>;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkClass>;
+  /**
+   * Check if a class exists on SAP
+   */
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP class on SAP
+   *
+   * @param name - Class name (e.g., 'ZCL_MY_CLASS')
+   * @param description - Short description
+   * @param packageName - Package to assign the class to
+   * @param options - Save options (transport)
+   * @param ctx - Optional ADK context
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkClass>;
+  /**
+   * Delete an ABAP class from SAP
+   *
+   * @param name - Class name
+   * @param options - Delete options (transport)
+   * @param ctx - Optional ADK context
+   */
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/intf/intf.model.d.ts
+/**
+ * Interface data type - imported from contract
+ *
+ * The schema wraps everything in an 'abapInterface' element, so we unwrap it here
+ * to provide a flat structure for ADK consumers.
+ */
+type InterfaceXml = InterfaceResponse['abapInterface'];
+/**
+ * ADK Interface object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Access interface-specific properties via `data`:
+ * - data.modeled, data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck
+ */
+declare class AdkInterface extends AdkMainObject<typeof Interface, InterfaceXml> {
+  static readonly kind: "Interface";
+  readonly kind: "Interface";
+  get objectUri(): string;
+  getSource(): Promise<string>;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkInterface>;
+  /**
+   * Check if an interface exists on SAP
+   */
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP interface on SAP
+   *
+   * @param name - Interface name (e.g., 'ZIF_MY_INTERFACE')
+   * @param description - Short description
+   * @param packageName - Package to assign the interface to
+   * @param options - Save options (transport)
+   * @param ctx - Optional ADK context
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkInterface>;
+  /**
+   * Delete an ABAP interface from SAP
+   *
+   * @param name - Interface name
+   * @param options - Delete options (transport)
+   * @param ctx - Optional ADK context
+   */
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/devc/devc.types.d.ts
+/**
+ * Package type (pak:packageType attribute)
+ */
+type PackageType = 'development' | 'structure' | 'main';
+/**
+ * Reference to another object (used for superPackage, etc.)
+ * Re-exported for backward compatibility
+ */
+type ObjectReference = AdtObjectReference;
+/**
+ * Package attributes (pak:attributes element)
+ */
+interface PackageAttributes {
+  readonly packageType: PackageType;
+  readonly isEncapsulated: boolean;
+  readonly isAddingObjectsAllowed: boolean;
+  readonly recordChanges: boolean;
+  readonly languageVersion: string;
+}
+/**
+ * Application component info
+ */
+interface ApplicationComponent {
+  readonly name: string;
+  readonly description: string;
+}
+/**
+ * Software component info
+ */
+interface SoftwareComponent {
+  readonly name: string;
+  readonly description: string;
+}
+/**
+ * Transport layer info
+ */
+interface TransportLayer {
+  readonly name: string;
+  readonly description: string;
+}
+/**
+ * Transport configuration
+ */
+interface TransportConfig {
+  readonly softwareComponent?: SoftwareComponent;
+  readonly transportLayer?: TransportLayer;
+}
+/**
+ * ABAP Package interface
+ *
+ * Plugins work with this interface - implementation is internal.
+ * Mirrors ADT pak:package structure.
+ */
+interface AbapPackage extends AbapObject {
+  readonly kind: 'Package';
+  readonly responsible: string;
+  readonly masterLanguage: string;
+  readonly language: string;
+  readonly version: string;
+  readonly createdAt: Date;
+  readonly createdBy: string;
+  readonly changedAt: Date;
+  readonly changedBy: string;
+  readonly attributes: PackageAttributes;
+  readonly superPackage?: AdtObjectReference;
+  readonly applicationComponent?: ApplicationComponent;
+  readonly transport?: TransportConfig;
+  /**
+   * Get direct subpackages
+   */
+  getSubpackages(): Promise<AbapPackage[]>;
+  /**
+   * Get objects contained in this package (direct, not recursive)
+   */
+  getObjects(): Promise<AbapObject[]>;
+  /**
+   * Get all objects recursively (includes subpackages)
+   */
+  getAllObjects(): Promise<AbapObject[]>;
+}
+//#endregion
+//#region src/objects/repository/devc/devc.model.d.ts
+/**
+ * Package data type - inferred from packagesContract response
+ *
+ * The schema wraps everything in a 'package' element, so we unwrap it here
+ * to provide a flat structure for ADK consumers.
+ */
+type PackageXml = NonNullable<PackageResponse['package']>;
+/**
+ * ADK Package object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - AdkMainObject: packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Note: For packages, the parent package is stored in `superPackage` not `packageRef`.
+ * The `package` getter is overridden to return the super package name.
+ */
+declare class AdkPackage extends AdkMainObject<typeof Package, PackageXml> implements AbapPackage {
+  static readonly kind: "Package";
+  readonly kind: "Package";
+  get objectUri(): string;
+  get package(): string;
+  get attributes(): PackageAttributes;
+  get superPackage(): ObjectReference | undefined;
+  get applicationComponent(): ApplicationComponent | undefined;
+  get transport(): TransportConfig | undefined;
+  getSubpackages(): Promise<AbapPackage[]>;
+  getObjects(): Promise<AbapObject[]>;
+  getAllObjects(): Promise<AbapObject[]>;
+  load(): Promise<this>;
+  protected get wrapperKey(): "package";
+  protected get crudContract(): any;
+  /**
+   * Get skeleton data for package creation (POST).
+   *
+   * SAP requires ALL elements in the Package xs:sequence, even if empty.
+   * The sequence order is: attributes, superPackage, extensionAlias, switch,
+   * applicationComponent, transport, translation, useAccesses,
+   * packageInterfaces, subPackages.
+   * Missing elements cause "System expected the element ..." 400 errors.
+   */
+  protected getSkeletonData(): Promise<Record<string, unknown>>;
+  /**
+   * Get a package by name
+   *
+   * @param name - Package name (e.g., '$TMP', 'ZPACKAGE')
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static get(name: string, ctx?: AdkContext): Promise<AdkPackage>;
+  /**
+   * Check if a package exists on SAP
+   *
+   * @param name - Package name
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   * @returns true if package exists, false otherwise
+   */
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new package on SAP
+   *
+   * Builds an AdkPackage with the given data and saves it in 'create' mode.
+   *
+   * @param name - Package name (e.g., 'ZABAPGIT_EXAMPLES_CLAS')
+   * @param data - Package data (superPackage, attributes, transport, etc.)
+   * @param options - Save options (transport request)
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static create(name: string, data: Partial<PackageXml>, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkPackage>;
+  /**
+   * Delete an ABAP package from SAP
+   *
+   * @param name - Package name
+   * @param options - Delete options (transport, lockHandle)
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/prog/prog.model.d.ts
+/**
+ * Program data type - unwrap from root element
+ *
+ * The schema wraps everything in an 'abapProgram' element, so we unwrap it here
+ * to provide a flat structure for ADK consumers.
+ */
+type ProgramXml = ProgramResponse['abapProgram'];
+/**
+ * ADK Program object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Access program-specific properties via `data`:
+ * - data.programType, data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck
+ */
+declare class AdkProgram extends AdkMainObject<typeof Program, ProgramXml> {
+  static readonly kind: "Program";
+  readonly kind: "Program";
+  get objectUri(): string;
+  getSource(): Promise<string>;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkProgram>;
+  /**
+   * Check if a program exists on SAP
+   */
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP program on SAP
+   *
+   * @param name - Program name (e.g., 'ZMYPROGRAM')
+   * @param description - Short description
+   * @param packageName - Package to assign the program to
+   * @param options - Save options (transport)
+   * @param ctx - Optional ADK context
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkProgram>;
+  /**
+   * Delete an ABAP program from SAP
+   *
+   * @param name - Program name
+   * @param options - Delete options (transport)
+   * @param ctx - Optional ADK context
+   */
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/incl/incl.model.d.ts
+/**
+ * Include data type - unwrap from root element.
+ *
+ * The schema wraps everything in an 'abapInclude' element, so we unwrap
+ * it here to provide a flat structure for ADK consumers.
+ */
+type IncludeXml = IncludeResponse['abapInclude'];
+/**
+ * ADK Include object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - AdkObject: name, type, description, version, language, changedBy/At,
+ *   createdBy/At, links
+ * - AdkMainObject: package, packageRef, responsible, masterLanguage,
+ *   masterSystem, abapLanguageVersion
+ *
+ * Access include-specific properties via `data`:
+ * - data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck,
+ *   data.contextRef (pointer to the main program)
+ */
+declare class AdkInclude extends AdkMainObject<typeof Include, IncludeXml> {
+  static readonly kind: "Include";
+  readonly kind: "Include";
+  get objectUri(): string;
+  getSource(): Promise<string>;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  /**
+   * Skeleton POST data for includes.
+   *
+   * Extends the base skeleton (name/type/description/packageRef) with
+   * `contextRef`, which sapcli's `sap.adt.Include(..., master=...)` serializes
+   * at creation time. Without this the include would be created detached
+   * from its main program.
+   */
+  protected getSkeletonData(): Promise<Record<string, unknown>>;
+  static get(name: string, ctx?: AdkContext): Promise<AdkInclude>;
+  /**
+   * Check if an include exists on SAP
+   */
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP include on SAP
+   *
+   * @param name - Include name (e.g., 'ZMY_INCLUDE')
+   * @param description - Short description
+   * @param packageName - Package to assign the include to
+   * @param options - Save options (transport, master program)
+   * @param ctx - Optional ADK context
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+    master?: string;
+  }, ctx?: AdkContext): Promise<AdkInclude>;
+  /**
+   * Delete an ABAP include from SAP
+   *
+   * @param name - Include name
+   * @param options - Delete options (transport, lockHandle)
+   * @param ctx - Optional ADK context
+   */
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/fugr/fugr.model.d.ts
+/**
+ * Function group data type - unwrap from root element
+ *
+ * The schema wraps everything in an 'abapFunctionGroup' element, so we unwrap it here
+ * to provide a flat structure for ADK consumers.
+ */
+type FunctionGroupXml = FunctionGroupResponse['abapFunctionGroup'];
+/**
+ * ADK Function Group object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - AdkObject: name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - AdkMainObject: package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Access function group-specific properties via `data`:
+ * - data.sourceUri, data.fixPointArithmetic, data.activeUnicodeCheck
+ */
+declare class AdkFunctionGroup extends AdkMainObject<typeof FunctionGroup, FunctionGroupXml> {
+  static readonly kind: "FunctionGroup";
+  readonly kind: "FunctionGroup";
+  get objectUri(): string;
+  getSource(): Promise<string>;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkFunctionGroup>;
+  /**
+   * Check if a function group exists on SAP
+   */
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP function group on SAP
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkFunctionGroup>;
+  /**
+   * Delete an ABAP function group from SAP
+   */
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/fugr/func/func.model.d.ts
+/**
+ * Function module data type - unwrap from root element
+ *
+ * The schema wraps everything in an 'abapFunctionModule' element, so we unwrap it here
+ * to provide a flat structure for ADK consumers.
+ */
+type FunctionModuleXml = FunctionModuleResponse['abapFunctionModule'];
+/**
+ * ADK Function Module object
+ *
+ * Function modules are child objects of function groups. Unlike main objects
+ * (classes, interfaces, etc.), they don't have their own package reference.
+ * All API operations require the parent group name in the URL path.
+ *
+ * Key differences from AdkMainObject:
+ * - Requires `groupName` for URI construction and all CRUD operations
+ * - Overrides lock/unlock/load/save to pass groupName to contract calls
+ * - No packageRef (lives within parent function group's package)
+ */
+declare class AdkFunctionModule extends AdkObject<typeof FunctionModule, FunctionModuleXml> {
+  static readonly kind: "FunctionModule";
+  readonly kind: "FunctionModule";
+  /** Parent function group name */
+  groupName: string;
+  /**
+   * Constructor supports two calling patterns:
+   *
+   * 1. Direct (3-arg): `new AdkFunctionModule(ctx, groupName, nameOrData)`
+   *    Used by static factory method and when group name is known upfront.
+   *
+   * 2. Factory (2-arg): `new AdkFunctionModule(ctx, data)`
+   *    Used by ADK factory's `getWithData()`. The groupName is extracted from
+   *    `data._groupName` or `data.containerRef.name`.
+   */
+  constructor(ctx: AdkContext, groupNameOrData: string | FunctionModuleXml, dataOrName?: FunctionModuleXml | string);
+  get objectUri(): string;
+  get collectionUri(): string;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  /**
+   * Load function module data from SAP
+   *
+   * Overrides base to pass groupName as first arg to contract.get()
+   */
+  load(): Promise<this>;
+  /**
+   * Get skeleton data for FM creation (POST).
+   *
+   * FMs only need name, type, description, and processing attributes.
+   * No packageRef — FMs inherit the package from their parent FUGR.
+   */
+  protected getSkeletonData(): Promise<Record<string, unknown>>;
+  /**
+   * Execute the typed contract call for save
+   *
+   * Overrides base to pass groupName to contract.put()/post()
+   */
+  protected saveViaContract(mode: 'create' | 'update', options: {
+    transport?: string;
+    lockHandle?: string;
+  }): Promise<void>;
+  /**
+   * Check if the function module exists on the SAP system.
+   *
+   * Overrides base to pass groupName to contract.get()
+   */
+  protected checkObjectExists(): Promise<boolean>;
+  /**
+   * Refresh cached ETags after acquiring a lock.
+   *
+   * FM's savePendingSources() does a metadata PUT first (to apply processingType),
+   * then a source PUT. Both need fresh ETags after locking.
+   * The contract uses groupName + name (potentially UPPERCASE), so we must
+   * refresh via the contract to match the same cache key.
+   */
+  protected refreshETagsAfterLock(): Promise<void>;
+  /**
+   * Strip the parameter comment block from FM source code.
+   *
+   * abapGit serializes FM source with a "Local Interface" comment block
+   * that describes IMPORTING/EXPORTING/CHANGING/TABLES/EXCEPTIONS.
+   * SAP ADT rejects this block when saving source — it manages the
+   * interface metadata separately. Strip it before sending.
+   *
+   * Pattern:
+   * ```
+   * *"----------------------------------------------------------------------
+   * *"*"Local Interface:
+   * *"  IMPORTING ...
+   * *"----------------------------------------------------------------------
+   * ```
+   */
+  private stripParameterCommentBlock;
+  /**
+   * Save pending source for function module.
+   *
+   * Overrides base to:
+   * 1. PUT metadata first (SAP ignores processingType and other attributes during POST)
+   * 2. Refresh source ETag (metadata PUT changes the object version)
+   * 3. Strip the parameter comment block that abapGit includes
+   * 4. Use the FM-specific source endpoint via groupName
+   */
+  protected savePendingSources(options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  /**
+   * Extract the body of a FUNCTION...ENDFUNCTION block.
+   *
+   * SAP reconstructs the FUNCTION header when returning source code:
+   *   Local:  `FUNCTION zage_fm.`                         (lowercase, period inline)
+   *   SAP:    `FUNCTION ZAGE_FM\n " template comment"\n.` (uppercase, period on own line)
+   *
+   * The body between the header and ENDFUNCTION is identical, so we compare
+   * only that part. The header ends at the first period that terminates the
+   * FUNCTION statement (either inline `FUNCTION name.` or on a separate line `.`).
+   */
+  private extractFunctionBody;
+  /**
+   * Pre-lock comparison for FM source.
+   *
+   * Overrides base to:
+   * 1. Strip parameter comment block from local source
+   * 2. Extract only the function body (between FUNCTION header and ENDFUNCTION)
+   *    from both local and SAP source, because SAP reconstructs the FUNCTION
+   *    header with uppercase name and template comments.
+   */
+  protected checkPendingSourcesUnchanged(): Promise<void>;
+  getSource(): Promise<string>;
+  /**
+   * Get a function module by name
+   *
+   * @param groupName - Parent function group name
+   * @param name - Function module name
+   * @param ctx - Optional ADK context (uses global if not provided)
+   */
+  static get(groupName: string, name: string, ctx?: AdkContext): Promise<AdkFunctionModule>;
+  /**
+   * Check if a function module exists on SAP
+   */
+  static exists(groupName: string, name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP function module on SAP
+   */
+  static create(groupName: string, name: string, description: string, options?: {
+    transport?: string;
+    processingType?: string;
+  }, ctx?: AdkContext): Promise<AdkFunctionModule>;
+  /**
+   * Delete a function module from SAP
+   */
+  static delete(groupName: string, name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/cts/transport/transport.types.d.ts
+/**
+ * Full response type from TransportService.get()
+ *
+ * The schema wraps everything in a 'root' element, so we unwrap it here
+ * to provide a flat structure for ADK consumers.
+ */
+type TransportData = TransportGetResponse['root'];
+/** Request data from schema */
+type TransportRequestData = NonNullable<TransportData['request']>;
+/** Task data from schema */
+type TransportTaskData = NonNullable<TransportRequestData['task']> extends (infer T)[] ? T : NonNullable<TransportRequestData['task']>;
+/** Object data from schema */
+type TransportObjectData = NonNullable<TransportTaskData['abap_object']> extends (infer T)[] ? T : NonNullable<TransportTaskData['abap_object']>;
+/** Transport status codes */
+type TransportStatus = 'D' | 'R' | 'N';
+/** Transport type */
+type TransportType = 'K' | 'W' | 'T' | 'C';
+type TransportTask = TransportTaskData;
+type TransportObject = TransportObjectData;
+/**
+ * Options for creating a transport
+ */
+interface TransportCreateOptions {
+  description: string;
+  type?: TransportType;
+  target?: string;
+  project?: string;
+  owner?: string;
+}
+/**
+ * Options for updating a transport
+ */
+interface TransportUpdateOptions {
+  description?: string;
+  target?: string;
+  owner?: string;
+}
+/**
+ * Result of release operation
+ */
+interface ReleaseResult {
+  success: boolean;
+  message?: string;
+}
+//#endregion
+//#region src/objects/cts/transport/transport-object.d.ts
+/**
+ * Transport Object - wrapper for ABAP objects in a transport
+ */
+declare class AdkTransportObject {
+  private readonly data;
+  constructor(data: TransportObjectData);
+  get pgmid(): string;
+  get type(): string;
+  get name(): string;
+  get wbtype(): string | undefined;
+  get objectInfo(): string | undefined;
+  get objectDescription(): string | undefined;
+  get lockStatus(): string | undefined;
+  get uri(): string | undefined;
+  /** Full object key (PGMID/TYPE/NAME) */
+  get key(): string;
+  /** Raw schema data */
+  get raw(): TransportObjectData;
+}
+//#endregion
+//#region src/objects/cts/transport/transport.d.ts
+/** Clear config cache (for testing) */
+declare function clearConfigCache(): void;
+interface TransportObjectDataInternal {
+  name: string;
+  type: string;
+  response: TransportData;
+}
+/**
+ * Transport Request - main transport object
+ *
+ * Handles both requests (K) and can be extended for tasks (T).
+ * Uses ADT contracts directly - no intermediate service layer.
+ */
+declare class AdkTransportRequest extends AdkObject<typeof TransportRequest, TransportObjectDataInternal> {
+  readonly kind: "TransportRequest";
+  protected _tasks?: AdkTransportTask[];
+  protected _objects?: AdkTransportObject[];
+  constructor(ctx: AdkContext, dataOrNumber: TransportData | string);
+  protected get response(): TransportData;
+  /** The item's data - override in subclass for different source */
+  protected get itemData(): TransportRequestData;
+  get objectUri(): string;
+  load(): Promise<this>;
+  get itemType(): 'request' | 'task';
+  get number(): string;
+  get owner(): string;
+  get description(): string;
+  get status(): string;
+  get statusText(): string;
+  get target(): string;
+  get targetDescription(): string;
+  get uri(): string;
+  get parent(): string;
+  get lastChangedAt(): Date | undefined;
+  /** Tasks belonging to this transport request */
+  get tasks(): AdkTransportTask[];
+  /**
+   * All objects in this request (aggregated from tasks)
+   * Override in AdkTransportTask for direct objects
+   */
+  get objects(): AdkTransportObject[];
+  release(): Promise<ReleaseResult>;
+  releaseAll(): Promise<ReleaseResult>;
+  update(changes: TransportUpdateOptions): Promise<void>;
+  delete(): Promise<void>;
+  /**
+   * Reassign ownership of this transport (and optionally all tasks) to a new user.
+   *
+   * @param newOwner - SAP username to become the new owner
+   * @param recursive - When true, also reassign all modifiable tasks
+   */
+  reassign(newOwner: string, recursive?: boolean): Promise<void>;
+  /**
+   * Create a new transport request
+   *
+   * @param options - Transport creation options
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static create(options: TransportCreateOptions, ctx?: AdkContext): Promise<AdkTransportRequest>;
+  /**
+   * Get a transport request by number
+   *
+   * @param number - Transport number (e.g., 'S0DK900001')
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static get(number: string, ctx?: AdkContext): Promise<AdkTransportRequest>;
+  /**
+   * List all transports for the current user
+   *
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static list(ctx?: AdkContext): Promise<AdkTransportRequest[]>;
+  /**
+   * Get current user from the system metadata
+   *
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static getCurrentUser(ctx?: AdkContext): Promise<string>;
+}
+/**
+ * Transport Task - child of a transport request
+ *
+ * Minimal overrides:
+ * - itemData: from response.task instead of response.request
+ * - objects: direct from task, not aggregated
+ * - request: parent reference
+ * - No tasks, no CRUD
+ */
+declare class AdkTransportTask extends AdkTransportRequest {
+  private _parentRequest?;
+  private readonly parentRef?;
+  constructor(ctx: AdkContext, dataOrNumber: TransportData | string, parentRef?: AdkTransportRequest);
+  protected get itemData(): TransportRequestData;
+  get tasks(): AdkTransportTask[];
+  get objects(): AdkTransportObject[];
+  /** Parent transport request */
+  get request(): AdkTransportRequest;
+  /**
+   * Get a transport task by number
+   *
+   * @param number - Task number (e.g., 'S0DK900001')
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   */
+  static get(number: string, ctx?: AdkContext): Promise<AdkTransportTask>;
+}
+//#endregion
+//#region src/objects/ddic/doma/doma.model.d.ts
+/**
+ * Domain data type - unwrap from schema root element
+ */
+type DomainXml = DomainResponse['domain'];
+/**
+ * ADK Domain object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Domain-specific properties via `data`:
+ * - data.typeInformation (dataType, length, decimals, outputLength)
+ * - data.outputInformation (conversionExit, signPresentation, lowerCase)
+ * - data.fixedValues
+ */
+declare class AdkDomain extends AdkMainObject<typeof Domain, DomainXml> {
+  static readonly kind: "Domain";
+  readonly kind: "Domain";
+  get objectUri(): string;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkDomain>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP domain on SAP.
+   *
+   * Note: Domains are metadata-only objects (no source code). After creation,
+   * use the `adt get domain <name>` command or abapGit-based deploy to fill in
+   * the domain properties (data type, field length, etc.).
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkDomain>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/ddic/dtel/dtel.model.d.ts
+/**
+ * Data Element data type - unwrap from wrapper root element
+ * SAP wraps DTEL content in a blue:wbobj element extending AdtMainObject
+ */
+type DataElementXml = DataElementResponse['wbobj'];
+/**
+ * ADK Data Element object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Data element-specific properties via `data`:
+ * - data.typeKind, data.typeName, data.dataType
+ * - data.shortDescription, data.mediumDescription, data.longDescription, data.headingDescription
+ * - data.searchHelp
+ */
+declare class AdkDataElement extends AdkMainObject<typeof DataElement, DataElementXml> {
+  static readonly kind: "DataElement";
+  readonly kind: "DataElement";
+  get objectUri(): string;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkDataElement>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP data element on SAP.
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkDataElement>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/ddic/tabl/tabl.model.d.ts
+/**
+ * Table/Structure data type - unwrap from blueSource wrapper root element
+ */
+type TableXml = TableResponse['blueSource'];
+/**
+ * ADK Table object (database table - TABL/DT)
+ */
+declare class AdkTable extends AdkMainObject<typeof Table, TableXml> {
+  static readonly kind: "Table";
+  readonly kind: "Table";
+  get objectUri(): string;
+  /**
+   * Get CDS-style table source code from SAP
+   * Returns the ABAP source definition (annotations + field definitions)
+   */
+  getSource(): Promise<string>;
+  /**
+   * Get table technical settings (DD09L data)
+   * Returns XML from /sap/bc/adt/ddic/db/settings/{name}
+   */
+  getSettings(): Promise<string>;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkTable>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP database table on SAP.
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkTable>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+/**
+ * ADK Structure object (TABL/DS)
+ */
+declare class AdkStructure extends AdkMainObject<typeof Structure, TableXml> {
+  static readonly kind: "Structure";
+  readonly kind: "Structure";
+  get objectUri(): string;
+  /**
+   * Get CDS-style structure source code from SAP
+   * Returns the ABAP source definition (annotations + field definitions)
+   */
+  getSource(): Promise<string>;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkStructure>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new ABAP structure on SAP.
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkStructure>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/ddic/ttyp/ttyp.model.d.ts
+/**
+ * Table Type data type - unwrap from schema root element
+ */
+type TableTypeXml = TableTypeResponse['tableType'];
+/**
+ * ADK Table Type object
+ *
+ * Inherits from AdkMainObject which provides:
+ * - name, type, description, version, language, changedBy/At, createdBy/At, links
+ * - package, packageRef, responsible, masterLanguage, masterSystem, abapLanguageVersion
+ *
+ * Table type-specific properties via `data`:
+ * - data.rowType (typeName, typeCategory, tableTypeSchemaReference)
+ * - data.primaryKey
+ * - data.secondaryKeys
+ */
+declare class AdkTableType extends AdkMainObject<typeof TableType, TableTypeXml> {
+  static readonly kind: "TableType";
+  readonly kind: "TableType";
+  get objectUri(): string;
+  protected get wrapperKey(): string;
+  protected get crudContract(): any;
+  static get(name: string, ctx?: AdkContext): Promise<AdkTableType>;
+}
+//#endregion
+//#region src/base/kinds.d.ts
+/**
+ * ADK Object Kinds
+ *
+ * Central registry of all ADK object types.
+ * Import specific kinds for type-safe usage:
+ *
+ * @example
+ * import { TransportRequest } from '../base/kinds';
+ * class AdkTransportRequest extends AdkObject<typeof TransportRequest> { ... }
+ */
+declare const TransportRequest: "TransportRequest";
+declare const TransportTask$1: "TransportTask";
+declare const Package: "Package";
+declare const Class: "Class";
+declare const Interface: "Interface";
+declare const FunctionGroup: "FunctionGroup";
+declare const FunctionModule: "FunctionModule";
+declare const Program: "Program";
+declare const Include: "Include";
+declare const Table: "Table";
+declare const Structure: "Structure";
+declare const DataElement: "DataElement";
+declare const Domain: "Domain";
+declare const TableType: "TableType";
+declare const MessageClass: "MessageClass";
+declare const EnhancementSpot: "EnhancementSpot";
+/** Union type of all ADK kinds */
+type AdkKind = typeof TransportRequest | typeof TransportTask$1 | typeof Package | typeof Class | typeof Interface | typeof FunctionGroup | typeof FunctionModule | typeof Program | typeof Include | typeof Table | typeof Structure | typeof DataElement | typeof Domain | typeof TableType | typeof MessageClass | typeof EnhancementSpot;
+/**
+ * Maps ADK kind to concrete object type
+ *
+ * Enables type-safe factory methods:
+ * ```ts
+ * const cls = factory.byKind(Class, 'ZCL_TEST');  // → AdkClass
+ * const intf = factory.byKind(Interface, 'ZIF'); // → AdkInterface
+ * ```
+ */
+type AdkObjectForKind<K extends AdkKind> = K extends typeof Class ? AdkClass : K extends typeof Interface ? AdkInterface : K extends typeof Package ? AdkPackage : K extends typeof Program ? AdkProgram : K extends typeof Include ? AdkInclude : K extends typeof FunctionGroup ? AdkFunctionGroup : K extends typeof FunctionModule ? AdkFunctionModule : K extends typeof TransportRequest ? AdkTransportRequest : K extends typeof TransportTask$1 ? AdkTransportTask : K extends typeof Domain ? AdkDomain : K extends typeof DataElement ? AdkDataElement : K extends typeof Table ? AdkTable : K extends typeof Structure ? AdkStructure : K extends typeof TableType ? AdkTableType : AdkObject;
+//#endregion
+//#region src/base/types.d.ts
+/**
+ * Base interface for all ABAP objects
+ */
+interface AbapObject {
+  readonly kind: AdkKind | string;
+  readonly name: string;
+  readonly package: string;
+  readonly description: string;
+  /**
+   * ADT object type (e.g., 'DEVC/K', 'CLAS/OC')
+   */
+  readonly type: string;
+}
+//#endregion
+//#region src/base/object-set.d.ts
+/**
+ * Result of bulk save operation
+ */
+interface BulkSaveResult {
+  /** Number of successfully saved objects */
+  success: number;
+  /** Number of objects that failed to save */
+  failed: number;
+  /** Number of unchanged objects (skipped) */
+  unchanged: number;
+  /** Details per object */
+  results: Array<{
+    object: AdkObject;
+    success: boolean; /** True if object was skipped because source is identical to SAP */
+    unchanged?: boolean;
+    error?: string;
+  }>;
+}
+/**
+ * Options for bulk save operation
+ */
+interface BulkSaveOptions extends SaveOptions {
+  /** Continue saving remaining objects if one fails (default: true) */
+  continueOnError?: boolean;
+  /** Callback for progress reporting */
+  onProgress?: (processed: number, total: number, current: AdkObject) => void;
+}
+/**
+ * Options for bulk activation
+ */
+interface BulkActivateOptions {
+  /** Callback for progress reporting */
+  onProgress?: (message: string) => void;
+}
+/**
+ * ADK Object Set - Collection of objects with bulk operations
+ *
+ * A semantic layer for managing collections of ADK objects and
+ * performing bulk operations like save and activate.
+ */
+declare class AdkObjectSet {
+  private readonly ctx;
+  private readonly objects;
+  constructor(ctx: AdkContext);
+  /**
+   * Add a single object to the set
+   *
+   * Propagates the set's context (lockService, lockStore) to the object
+   * so that objects created by plugins with a bare { client } context
+   * inherit the services configured on the set.
+   */
+  add(object: AdkObject): this;
+  /**
+   * Add multiple objects to the set
+   */
+  addAll(objects: AdkObject[]): this;
+  /**
+   * Remove an object from the set
+   */
+  remove(object: AdkObject): this;
+  /**
+   * Clear all objects from the set
+   */
+  clear(): this;
+  /**
+   * Get all objects in the set
+   */
+  getAll(): AdkObject[];
+  /**
+   * Get number of objects in the set
+   */
+  get size(): number;
+  /**
+   * Check if set is empty
+   */
+  get isEmpty(): boolean;
+  /**
+   * Filter objects by type
+   */
+  filterByType(type: string): AdkObject[];
+  /**
+   * Filter objects by kind
+   */
+  filterByKind(kind: string): AdkObject[];
+  /**
+   * Iterate over objects
+   */
+  [Symbol.iterator](): Iterator<AdkObject>;
+  /**
+   * Save all objects in the set
+   *
+   * Saves each object individually, handling lock/unlock per object.
+   * By default continues on error to save as many objects as possible.
+   *
+   * @param options - Save options (transport, inactive, continueOnError)
+   * @returns Result with success/failure counts and details
+   */
+  saveAll(options?: BulkSaveOptions): Promise<BulkSaveResult>;
+  /**
+   * Activate all objects in the set (bulk activation)
+   *
+   * Uses SAP's bulk activation endpoint for efficiency.
+   * All objects are activated in a single request.
+   *
+   * @param options - Activation options
+   * @returns Activation result with success/failure counts
+   */
+  activateAll(options?: BulkActivateOptions): Promise<ActivationResult>;
+  /**
+   * Save all objects as inactive, then bulk activate, then unlock
+   *
+   * This is the recommended pattern for deploying multiple objects:
+   * 1. Save all objects as inactive (handles dependencies)
+   * 2. Bulk activate all saved objects
+   * 3. Unlock all objects
+   *
+   * @param options - Save options (transport required)
+   * @returns Combined result of save and activation
+   */
+  deploy(options: BulkSaveOptions & {
+    activate?: boolean;
+  }): Promise<{
+    save: BulkSaveResult;
+    activation?: ActivationResult;
+  }>;
+  /**
+   * Lock all objects in the set
+   *
+   * @returns Array of lock handles
+   */
+  lockAll(): Promise<LockHandle[]>;
+  /**
+   * Unlock all objects in the set
+   */
+  unlockAll(): Promise<void>;
+  /**
+   * Load all objects (fetch data from SAP)
+   *
+   * @param options - Load options
+   * @returns This set (for chaining)
+   */
+  loadAll(options?: {
+    parallel?: boolean;
+  }): Promise<this>;
+  /**
+   * Create an object set from an array of objects
+   */
+  static from(objects: AdkObject[], ctx: AdkContext): AdkObjectSet;
+  /**
+   * Create an object set by collecting from an async generator
+   *
+   * Collects all objects yielded by the generator into the set.
+   * Useful for collecting objects from format plugin export generators.
+   *
+   * @param generator - Async generator yielding AdkObject instances
+   * @param ctx - ADK context for the set
+   * @param options - Collection options
+   * @returns Promise resolving to populated AdkObjectSet
+   */
+  static fromGenerator(generator: AsyncGenerator<AdkObject>, ctx: AdkContext, options?: {
+    /** Filter function to include/exclude objects */filter?: (obj: AdkObject) => boolean; /** Callback for each object collected */
+    onObject?: (obj: AdkObject) => void;
+  }): Promise<AdkObjectSet>;
+}
+//#endregion
+//#region src/base/global-context.d.ts
+/**
+ * Initialize the global ADK context from an ADT client.
+ *
+ * Call this once during application bootstrap (e.g., in CLI initialization).
+ * After initialization, ADK objects can be used without passing context.
+ *
+ * @param client - ADT client v2 instance
+ * @throws Error if client is not provided
+ *
+ * @example
+ * ```ts
+ * import { initializeAdk } from '@abapify/adk';
+ * import { createAdtClient } from '@abapify/adt-client';
+ *
+ * const client = createAdtClient({ ... });
+ * initializeAdk(client);
+ *
+ * // Now ADK objects work without context
+ * const transport = await AdkTransportRequest.get('S0DK900001');
+ * ```
+ */
+declare function initializeAdk(client: AdtClient, options?: {
+  lockStore?: LockStore$1;
+  lockService?: LockService$1;
+}): void;
+/**
+ * Get the global ADK context.
+ *
+ * Used internally by ADK objects when no explicit context is provided.
+ *
+ * @returns The global ADK context
+ * @throws Error if ADK has not been initialized
+ *
+ * @example
+ * ```ts
+ * // Internal usage in ADK objects:
+ * static async get(number: string, ctx?: AdkContext): Promise<AdkTransportRequest> {
+ *   const context = ctx ?? getGlobalContext();
+ *   // ...
+ * }
+ * ```
+ */
+declare function getGlobalContext(): AdkContext;
+/**
+ * Check if ADK has been initialized.
+ *
+ * Useful for conditional logic or error handling.
+ *
+ * @returns true if initializeAdk() has been called
+ */
+declare function isAdkInitialized(): boolean;
+/**
+ * Reset the global ADK context.
+ *
+ * Primarily for testing purposes. Clears the global context.
+ */
+declare function resetAdk(): void;
+/**
+ * Get the global context or return undefined if not initialized.
+ *
+ * Unlike getGlobalContext(), this doesn't throw - useful when you want
+ * to check if context exists before using it.
+ *
+ * @returns The global context or undefined
+ */
+declare function tryGetGlobalContext(): AdkContext | undefined;
+//#endregion
+//#region src/objects/repository/intf/intf.types.d.ts
+/**
+ * ABAP Interface interface
+ *
+ * Plugins work with this interface - implementation is internal.
+ * Mirrors ADT intf:abapInterface structure.
+ */
+interface AbapInterface extends AbapObject {
+  readonly kind: 'Interface';
+  readonly responsible: string;
+  readonly masterLanguage: string;
+  readonly language: string;
+  readonly version: string;
+  readonly createdAt: Date;
+  readonly createdBy: string;
+  readonly changedAt: Date;
+  readonly changedBy: string;
+  readonly modeled: boolean;
+  readonly sourceUri: string;
+  readonly fixPointArithmetic: boolean;
+  readonly activeUnicodeCheck: boolean;
+  readonly packageRef?: AdtObjectReference;
+  /**
+   * Get interface source code
+   */
+  getSource(): Promise<string>;
+}
+//#endregion
+//#region src/objects/repository/prog/prog.types.d.ts
+/**
+ * ABAP Program interface
+ *
+ * Plugins work with this interface - implementation is internal.
+ * Mirrors ADT prog:abapProgram structure.
+ */
+interface AbapProgram extends AbapObject {
+  readonly kind: 'Program';
+  readonly responsible: string;
+  readonly masterLanguage: string;
+  readonly language: string;
+  readonly version: string;
+  readonly createdAt: Date;
+  readonly createdBy: string;
+  readonly changedAt: Date;
+  readonly changedBy: string;
+  readonly sourceUri: string;
+  readonly fixPointArithmetic: boolean;
+  readonly activeUnicodeCheck: boolean;
+  readonly programType?: string;
+  readonly packageRef?: AdtObjectReference;
+  /**
+   * Get program source code
+   */
+  getSource(): Promise<string>;
+}
+//#endregion
+//#region src/objects/repository/incl/incl.types.d.ts
+/**
+ * ABAP Include interface
+ *
+ * Plugins work with this interface - implementation is internal.
+ * Mirrors ADT include:abapInclude structure.
+ */
+interface AbapInclude extends AbapObject {
+  readonly kind: 'Include';
+  readonly responsible: string;
+  readonly masterLanguage: string;
+  readonly language: string;
+  readonly version: string;
+  readonly createdAt: Date;
+  readonly createdBy: string;
+  readonly changedAt: Date;
+  readonly changedBy: string;
+  readonly sourceUri: string;
+  readonly fixPointArithmetic: boolean;
+  readonly activeUnicodeCheck: boolean;
+  readonly packageRef?: AdtObjectReference;
+  /** Reference to the "main" program that owns this include. */
+  readonly contextRef?: AdtObjectReference;
+  /** Get include source code */
+  getSource(): Promise<string>;
+}
+//#endregion
+//#region src/objects/repository/fugr/fugr.types.d.ts
+/**
+ * ABAP Function Group interface
+ *
+ * Plugins work with this interface - implementation is internal.
+ * Mirrors ADT fugr:abapFunctionGroup structure.
+ */
+interface AbapFunctionGroup extends AbapObject {
+  readonly kind: 'FunctionGroup';
+  readonly responsible: string;
+  readonly masterLanguage: string;
+  readonly language: string;
+  readonly version: string;
+  readonly createdAt: Date;
+  readonly createdBy: string;
+  readonly changedAt: Date;
+  readonly changedBy: string;
+  readonly sourceUri: string;
+  readonly fixPointArithmetic: boolean;
+  readonly activeUnicodeCheck: boolean;
+  readonly packageRef?: AdtObjectReference;
+  /**
+   * Get function group top-include source code
+   */
+  getSource(): Promise<string>;
+}
+//#endregion
+//#region src/objects/repository/fugr/func/func.types.d.ts
+/**
+ * Function module processing type
+ */
+type FunctionModuleProcessingType = 'normal' | 'rfc' | 'update';
+/**
+ * Function module release state
+ */
+type FunctionModuleReleaseState = 'notReleased' | 'internal' | 'external' | 'obsolete' | 'markedForRelease';
+/**
+ * ABAP Function Module interface
+ *
+ * Plugins work with this interface - implementation is internal.
+ * Mirrors ADT fmodules:abapFunctionModule structure.
+ */
+interface AbapFunctionModule extends AbapObject {
+  readonly kind: 'FunctionModule';
+  /** Parent function group name */
+  readonly groupName: string;
+  readonly version: string;
+  readonly language: string;
+  readonly createdAt: Date;
+  readonly createdBy: string;
+  readonly changedAt: Date;
+  readonly changedBy: string;
+  readonly sourceUri: string;
+  readonly processingType: FunctionModuleProcessingType;
+  readonly releaseState: FunctionModuleReleaseState;
+  readonly basXMLEnabled: boolean;
+  /**
+   * Get function module source code
+   */
+  getSource(): Promise<string>;
+}
+//#endregion
+//#region src/objects/cds/ddl.model.d.ts
+declare class AdkDdlSource {
+  readonly name: string;
+  protected readonly ctx: AdkContext;
+  constructor(ctx: AdkContext, name: string);
+  get objectUri(): string;
+  /** Placeholder description — full metadata requires additional SAP fetch */
+  get description(): string;
+  private get contract();
+  getSource(): Promise<string>;
+  saveMainSource(source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  lock(transport?: string): Promise<{
+    handle: string;
+  }>;
+  unlock(lockHandle: string): Promise<void>;
+  activate(): Promise<this>;
+  /**
+   * Get a DDL source (does not fetch metadata, just returns handle)
+   */
+  static get(name: string, ctx?: AdkContext): Promise<AdkDdlSource>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new CDS DDL source on SAP
+   *
+   * POST /sap/bc/adt/ddic/ddl/sources?corrNr=...
+   * Body matches the `ddl:source` schema (extends abapsource:AbapSourceMainObject).
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkDdlSource>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/cds/dcl.model.d.ts
+declare class AdkDclSource {
+  readonly name: string;
+  protected readonly ctx: AdkContext;
+  constructor(ctx: AdkContext, name: string);
+  get objectUri(): string;
+  /** Placeholder description — full metadata requires additional SAP fetch */
+  get description(): string;
+  private get contract();
+  getSource(): Promise<string>;
+  saveMainSource(source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  lock(transport?: string): Promise<{
+    handle: string;
+  }>;
+  unlock(lockHandle: string): Promise<void>;
+  activate(): Promise<this>;
+  static get(name: string, ctx?: AdkContext): Promise<AdkDclSource>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new CDS DCL source on SAP
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkDclSource>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/bdef/bdef.model.d.ts
+declare class AdkBehaviorDefinition {
+  /** Static ADK kind marker — used by abapGit handler registry if needed. */
+  static readonly kind: "BehaviorDefinition";
+  readonly kind: "BehaviorDefinition";
+  readonly name: string;
+  protected readonly ctx: AdkContext;
+  constructor(ctx: AdkContext, name: string);
+  get objectUri(): string;
+  /** Placeholder description — full metadata requires additional SAP fetch */
+  get description(): string;
+  private get contract();
+  getSource(): Promise<string>;
+  saveMainSource(source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  lock(transport?: string): Promise<{
+    handle: string;
+  }>;
+  unlock(lockHandle: string): Promise<void>;
+  activate(): Promise<this>;
+  /**
+   * Get a BDEF (validates it exists by fetching source).
+   */
+  static get(name: string, ctx?: AdkContext): Promise<AdkBehaviorDefinition>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new BDEF on SAP.
+   *
+   * POST /sap/bc/adt/bo/behaviordefinitions?corrNr=...
+   * Body matches the `blue:blueSource` envelope (extends
+   * abapsource:AbapSourceMainObject).
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkBehaviorDefinition>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/badi/badi.model.d.ts
+declare class AdkBadi {
+  /** Static ADK kind marker. */
+  static readonly kind: "Badi";
+  readonly kind: "Badi";
+  readonly name: string;
+  protected readonly ctx: AdkContext;
+  constructor(ctx: AdkContext, name: string);
+  /** ADT URI (lowercase path segment — SAP convention). */
+  get objectUri(): string;
+  /** Placeholder description — real metadata arrives via GET/objectstructure. */
+  get description(): string;
+  private get contract();
+  getMetadata(): Promise<unknown>;
+  getSource(): Promise<string>;
+  saveMainSource(source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  lock(transport?: string): Promise<{
+    handle: string;
+  }>;
+  unlock(lockHandle: string): Promise<void>;
+  activate(): Promise<this>;
+  /** Fetch a BAdI / ENHO, validating existence via a metadata GET. */
+  static get(name: string, ctx?: AdkContext): Promise<AdkBadi>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new Enhancement Implementation (BAdI container).
+   *
+   * Trial systems typically reject this with HTTP 403 — this is an
+   * area that requires elevated authorisation on most SAP installs.
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkBadi>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/srvd/srvd.model.d.ts
+declare class AdkServiceDefinition {
+  /** Static ADK kind marker — used by abapGit handler registry if needed. */
+  static readonly kind: "ServiceDefinition";
+  readonly kind: "ServiceDefinition";
+  readonly name: string;
+  protected readonly ctx: AdkContext;
+  constructor(ctx: AdkContext, name: string);
+  get objectUri(): string;
+  /** Placeholder description — full metadata requires additional SAP fetch */
+  get description(): string;
+  private get contract();
+  getSource(): Promise<string>;
+  saveMainSource(source: string, options?: {
+    lockHandle?: string;
+    transport?: string;
+  }): Promise<void>;
+  lock(transport?: string): Promise<{
+    handle: string;
+  }>;
+  unlock(lockHandle: string): Promise<void>;
+  activate(): Promise<this>;
+  /**
+   * Get a SRVD (validates it exists by fetching source).
+   */
+  static get(name: string, ctx?: AdkContext): Promise<AdkServiceDefinition>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new SRVD on SAP.
+   *
+   * POST /sap/bc/adt/ddic/srvd/sources?corrNr=...
+   * Body matches the `srvd:source` envelope (extends
+   * abapsource:AbapSourceMainObject).
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkServiceDefinition>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/repository/srvb/srvb.model.d.ts
+declare class AdkServiceBinding {
+  /** Static ADK kind marker — used by abapGit handler registry if needed. */
+  static readonly kind: "ServiceBinding";
+  readonly kind: "ServiceBinding";
+  readonly name: string;
+  protected readonly ctx: AdkContext;
+  constructor(ctx: AdkContext, name: string);
+  get objectUri(): string;
+  /** Placeholder description — full metadata requires additional SAP fetch */
+  get description(): string;
+  private get contract();
+  /**
+   * Fetch the binding metadata document. SRVB has no source text;
+   * `getSource()` returns an empty string for uniform CLI parity.
+   */
+  getMetadata(): Promise<unknown>;
+  getSource(): Promise<string>;
+  lock(transport?: string): Promise<{
+    handle: string;
+  }>;
+  unlock(lockHandle: string): Promise<void>;
+  activate(): Promise<this>;
+  /**
+   * Publish (activate) the binding in the SAP Gateway.
+   * POST {basePath}/{name}/publishedstates
+   */
+  publish(): Promise<void>;
+  /**
+   * Unpublish (deactivate) the binding.
+   * DELETE {basePath}/{name}/publishedstates
+   */
+  unpublish(): Promise<void>;
+  /**
+   * Get a SRVB (validates it exists by fetching metadata).
+   */
+  static get(name: string, ctx?: AdkContext): Promise<AdkServiceBinding>;
+  static exists(name: string, ctx?: AdkContext): Promise<boolean>;
+  /**
+   * Create a new SRVB on SAP.
+   *
+   * POST /sap/bc/adt/businessservices/bindings?corrNr=...
+   * Body matches the `srvb:serviceBinding` envelope.
+   */
+  static create(name: string, description: string, packageName: string, options?: {
+    transport?: string;
+  }, ctx?: AdkContext): Promise<AdkServiceBinding>;
+  static delete(name: string, options?: {
+    transport?: string;
+    lockHandle?: string;
+  }, ctx?: AdkContext): Promise<void>;
+  static publish(name: string, ctx?: AdkContext): Promise<void>;
+  static unpublish(name: string, ctx?: AdkContext): Promise<void>;
+}
+//#endregion
+//#region src/objects/cts/transport-import.d.ts
+interface TransportObjectData$1 {
+  pgmid?: string;
+  type?: string;
+  name?: string;
+  wbtype?: string;
+  uri?: string;
+  obj_desc?: string;
+  obj_info?: string;
+  lock_status?: string;
+  /** Object function code (e.g. 'D' = deletion, 'K' = key, '' = modification) */
+  obj_func?: string;
+}
+/**
+ * Selector for filtering transport objects.
+ *
+ * All specified dimensions are ANDed together.
+ * Use '*' for a wildcard that matches any non-empty value.
+ */
+interface TransportObjectSelector {
+  /**
+   * Filter by object function code.
+   * 'D' = deletion only, 'K' = key only, '*' = any non-empty value, '' = empty (normal)
+   */
+  objFunc?: string | string[];
+  /**
+   * Filter by program ID.
+   * 'R3TR' = repository objects, 'LIMU' = sub-objects, '*' = any
+   */
+  pgmid?: string | string[];
+  /**
+   * Filter by object type (e.g. 'CLAS', 'TABL', '*' = any)
+   */
+  type?: string | string[];
+}
+interface TransportTaskData$1 {
+  number?: string;
+  owner?: string;
+  desc?: string;
+  status?: string;
+  status_text?: string;
+  abap_object?: TransportObjectData$1 | TransportObjectData$1[];
+}
+/**
+ * Check if an object ref matches all dimensions of a {@link TransportObjectSelector}.
+ *
+ * Exported so that consumers (e.g. import service) can reuse the same logic
+ * without duplicating it.
+ */
+declare function matchesSelector(obj: AdkTransportObjectRef, selector: TransportObjectSelector): boolean;
+/**
+ * Transport object reference - lightweight wrapper
+ *
+ * Contains metadata about an object in the transport.
+ * Call load() to get the full ADK object.
+ */
+declare class AdkTransportObjectRef {
+  private readonly ctx;
+  private readonly data;
+  constructor(ctx: AdkContext, data: TransportObjectData$1);
+  /** Program ID (R3TR, LIMU, etc.) */
+  get pgmid(): string;
+  /** Object type (CLAS, INTF, DOMA, etc.) */
+  get type(): string;
+  /** Object name */
+  get name(): string;
+  /** Workbench type (more specific type) */
+  get wbtype(): string | undefined;
+  /** Object URI for direct access */
+  get uri(): string | undefined;
+  /** Object description */
+  get description(): string | undefined;
+  /**
+   * Object function code (SAP OBJFUNC).
+   * 'D' = marked for deletion, 'K' = key entry, '' = regular modification.
+   */
+  get objFunc(): string;
+  /** Whether this object is marked for deletion (obj_func === 'D') */
+  get isDeleted(): boolean;
+  /** Full object key (PGMID/TYPE/NAME) */
+  get key(): string;
+  /**
+   * Load the full ADK object
+   *
+   * Uses the ADK factory to create the appropriate object type
+   * (AdkClass, AdkInterface, AdkPackage, etc.)
+   *
+   * @returns The loaded ADK object, or undefined if type not supported
+   */
+  load(): Promise<unknown>;
+  /** Raw data from API */
+  get raw(): TransportObjectData$1;
+}
+/**
+ * Transport task reference
+ */
+declare class AdkTransportTaskRef {
+  private readonly ctx;
+  private readonly data;
+  constructor(ctx: AdkContext, data: TransportTaskData$1);
+  get number(): string;
+  get owner(): string;
+  get description(): string;
+  get status(): string;
+  get statusText(): string;
+  /** Objects in this task */
+  get objects(): AdkTransportObjectRef[];
+}
+/**
+ * AdkTransport - Transport request for import operations
+ *
+ * Simple, focused API for importing transport objects:
+ *
+ * @example
+ * ```typescript
+ * const transport = await AdkTransport.get('DEVK900001');
+ *
+ * for (const objRef of transport.objects) {
+ *   console.log(`${objRef.type} ${objRef.name}`);
+ *   const adkObject = await objRef.load();
+ *   if (adkObject) {
+ *     // Serialize with plugin
+ *     await plugin.serialize(adkObject);
+ *   }
+ * }
+ * ```
+ */
+declare class AdkTransport {
+  private readonly ctx;
+  private readonly data;
+  private _objects?;
+  private _tasks?;
+  private constructor();
+  /** Transport number */
+  get number(): string;
+  /** Transport description */
+  get description(): string;
+  /** Transport owner */
+  get owner(): string;
+  /** Transport status (D=Modifiable, R=Released) */
+  get status(): string;
+  /** Transport status text */
+  get statusText(): string;
+  /** Transport target system */
+  get target(): string;
+  /** Object type (K=Request, T=Task) */
+  get objectType(): string;
+  /** Tasks belonging to this transport */
+  get tasks(): AdkTransportTaskRef[];
+  /**
+   * All objects in this transport
+   *
+   * Collects objects from:
+   * - Direct objects on request
+   * - Objects from all tasks
+   * - all_objects container (if present)
+   */
+  get objects(): AdkTransportObjectRef[];
+  private collectObjects;
+  /**
+   * Get objects filtered by type
+   *
+   * @param types - Object types to include (e.g., ['CLAS', 'INTF'])
+   */
+  getObjectsByType(...types: string[]): AdkTransportObjectRef[];
+  /**
+   * Get objects filtered by a {@link TransportObjectSelector}.
+   *
+   * All dimensions specified in the selector are ANDed together.
+   *
+   * @example
+   * ```typescript
+   * // Get only deletion objects with pgmid=R3TR
+   * const deleted = transport.getObjectsBySelector({ objFunc: 'D', pgmid: 'R3TR' });
+   * ```
+   */
+  getObjectsBySelector(selector: TransportObjectSelector): AdkTransportObjectRef[];
+  /**
+   * Convenience accessor for objects marked for deletion (obj_func === 'D').
+   *
+   * Equivalent to `getObjectsBySelector({ objFunc: 'D' })`.
+   */
+  get deletionObjects(): AdkTransportObjectRef[];
+  /**
+   * Get unique object types in this transport
+   */
+  getObjectTypes(): string[];
+  /**
+   * Get object count by type
+   */
+  getObjectCountByType(): Record<string, number>;
+  /** Raw API response (unwrapped) */
+  get raw(): TransportData;
+  /**
+   * Get a transport by number
+   *
+   * @param number - Transport number (e.g., 'DEVK900001')
+   * @param ctx - Optional ADK context (uses global context if not provided)
+   *
+   * @example
+   * ```typescript
+   * const transport = await AdkTransport.get('DEVK900001');
+   * console.log(`${transport.description} - ${transport.objects.length} objects`);
+   * ```
+   */
+  static get(number: string, ctx?: AdkContext): Promise<AdkTransport>;
+  /**
+   * Load multiple transports and merge their objects into a single view.
+   *
+   * De-duplication key is `pgmid/type/name`. When the same key appears in
+   * multiple transports the **first** occurrence wins (first transport in the
+   * `numbers` array). The source transport number is available via
+   * `AdkTransportObjectRef.sourceTransport`.
+   *
+   * @param numbers - Transport numbers to load and merge
+   * @param ctx     - Optional ADK context
+   *
+   * @example
+   * ```typescript
+   * const merged = await AdkTransport.merge(['DEVK900001', 'DEVK900002']);
+   * const deletions = merged.getObjectsBySelector({ objFunc: 'D' });
+   * ```
+   */
+  static merge(numbers: string[], ctx?: AdkContext): Promise<MergedTransportView>;
+}
+/**
+ * Result of resolving transport objects (single or multi-TR).
+ *
+ * Returned by {@link resolveTransportObjects}.
+ */
+interface ResolvedTransportObjects {
+  /** Deduplicated list of transport objects (first-win across TRs). */
+  objects: AdkTransportObjectRef[];
+  /** Maps each object key to the TR number it was sourced from. */
+  sourceTransportMap: Map<string, string>;
+}
+/**
+ * Load and resolve objects from one or more transport numbers, with optional
+ * selector-based filtering and deduplication across TRs.
+ *
+ * This is the shared logic used by both the CLI `cts tr objects` command and
+ * the MCP `cts_transport_objects` tool — extracted here to avoid duplication.
+ *
+ * @param transportNumbers - Ordered list of TR numbers (first-win deduplication).
+ * @param selector         - Optional dimension filter (objFunc, pgmid, type).
+ * @param ctx              - Optional ADK context (uses global context if omitted).
+ */
+declare function resolveTransportObjects(transportNumbers: string[], selector: TransportObjectSelector, ctx?: AdkContext): Promise<ResolvedTransportObjects>;
+/**
+ * Merged view of objects from multiple transports.
+ *
+ * De-duplicates by `pgmid/type/name`; first occurrence wins.
+ */
+declare class MergedTransportView {
+  private readonly _objects;
+  readonly transports: AdkTransport[];
+  constructor(transports: AdkTransport[]);
+  /** All objects across transports (deduplicated) */
+  get objects(): AdkTransportObjectRef[];
+  /** Objects matching a selector across all transports */
+  getObjectsBySelector(selector: TransportObjectSelector): AdkTransportObjectRef[];
+  /** Convenience: objects marked for deletion (obj_func === 'D') */
+  get deletionObjects(): AdkTransportObjectRef[];
+  /**
+   * Load multiple transports and return a merged view.
+   *
+   * @param numbers - Transport numbers to load and merge
+   * @param ctx     - Optional ADK context
+   */
+  static create(numbers: string[], ctx?: AdkContext): Promise<MergedTransportView>;
+}
+//#endregion
+//#region src/factory.d.ts
+/**
+ * Extract ADT type and name from XML
+ *
+ * Relies on adtcore:type and adtcore:name attributes which are
+ * the standard identifiers in ADT XML responses.
+ *
+ * @param xml - XML string from ADT response
+ * @returns Extracted type and name, or undefined if not found
+ */
+declare function parseXmlIdentity(xml: string): {
+  type: string;
+  name: string;
+} | undefined;
+/**
+ * Generic ADK object for unregistered types
+ *
+ * Provides core functionality (adtcore attributes, links)
+ * without type-specific features.
+ */
+declare class AdkGenericObject {
+  readonly adtType: string;
+  readonly adtMainType: string;
+  readonly adtSubType?: string;
+  protected readonly ctx: AdkContext;
+  protected _name: string;
+  protected _data?: unknown;
+  constructor(ctx: AdkContext, name: string, adtType: string);
+  get name(): string;
+  get type(): string;
+  /** Check if data is loaded */
+  get isLoaded(): boolean;
+  /** Get raw data (if loaded) */
+  get data(): unknown;
+  /** Set data (for manual population) */
+  setData(data: unknown): void;
+}
+/**
+ * ADK Factory - Generic object creation
+ */
+interface AdkFactory {
+  /** Context used by this factory */
+  readonly ctx: AdkContext;
+  /**
+   * Get object by name and ADT type
+   *
+   * Supports both full types (DEVC/K) and main types (DEVC).
+   * Returns deferred object - call load() to fetch data.
+   *
+   * @example
+   * const pkg = factory.get('ZPACKAGE', 'DEVC/K');
+   * await pkg.load();
+   *
+   * const cls = factory.get('ZCL_TEST', 'CLAS');
+   * await cls.load();
+   */
+  get(name: string, adtType: string): AdkObject | AdkGenericObject;
+  /**
+   * Get object with initial data (for deserialization)
+   *
+   * Creates object pre-populated with data - no load() needed.
+   * Used when deserializing from files rather than loading from SAP.
+   *
+   * @example
+   * const cls = factory.getWithData({ name: 'ZCL_TEST', description: 'Test' }, 'CLAS');
+   * // cls.isLoaded is true, no need to call load()
+   */
+  getWithData(data: Record<string, unknown>, adtType: string): AdkObject | AdkGenericObject;
+  /**
+   * Get object by ADK kind (type-safe)
+   *
+   * Returns correctly typed object based on kind.
+   * TypeScript infers the concrete return type from the kind parameter.
+   *
+   * @example
+   * import { Class, Interface } from '@abapify/adk';
+   * const cls = factory.byKind(Class, 'ZCL_TEST');     // → AdkClass
+   * const intf = factory.byKind(Interface, 'ZIF_TEST'); // → AdkInterface
+   */
+  byKind<K extends AdkKind>(kind: K, name: string): AdkObjectForKind<K>;
+  /**
+   * Create object from XML response
+   *
+   * Parses XML to extract type and name, then constructs
+   * the correct object type.
+   *
+   * @example
+   * const xml = await client.fetch('/sap/bc/adt/oo/classes/ZCL_TEST');
+   * const cls = factory.fromXml(xml);
+   */
+  fromXml(xml: string): AdkObject | AdkGenericObject | undefined;
+  /**
+   * Create new object (for creation workflows)
+   *
+   * Returns deferred object without name - used when
+   * creating new objects in SAP.
+   */
+  create(adtType: string): AdkObject | AdkGenericObject;
+}
+/**
+ * Create ADK factory
+ *
+ * @param ctx - ADK context with services
+ * @returns Factory instance
+ */
+declare function createAdkFactory(ctx: AdkContext): AdkFactory;
+/**
+ * Create ADK factory from ADT client
+ *
+ * Builds context from client and returns factory.
+ * This is the main entry point for most users.
+ *
+ * @example
+ * import { createAdtClient } from '@abapify/adt-client';
+ * import { createAdk } from '@abapify/adk';
+ *
+ * const client = createAdtClient({ ... });
+ * const adk = createAdk(client);
+ *
+ * const cls = adk.get('ZCL_TEST', 'CLAS');
+ * await cls.load();
+ */
+declare function createAdk(client: AdtClient$1): AdkFactory;
+//#endregion
+//#region src/base/registry.d.ts
+/** Constructor signature for ADK objects */
+type AdkObjectConstructor<T extends AdkObject<AdkKind, any> = AdkObject<AdkKind, any>> = new (ctx: AdkContext, nameOrData: string | any) => T;
+/** How to transform object name for the URI path segment */
+type NameTransform = 'lowercase' | 'preserve';
+/** Registry entry with constructor and kind */
+interface RegistryEntry {
+  readonly kind: AdkKind;
+  readonly constructor: AdkObjectConstructor;
+  /** ADT REST endpoint path segment (e.g., 'oo/classes', 'ddic/tabletypes') */
+  readonly endpoint?: string;
+  /** How to transform the object name in URIs (default: lowercase) */
+  readonly nameTransform?: NameTransform;
+  /** Optional name normalizer — e.g., strip SAPL prefix for FUGR */
+  readonly normalizeName?: (name: string) => string;
+}
+/**
+ * Parse ADT type into components
+ *
+ * @example
+ * parseAdtType("DEVC/K") // { full: "DEVC/K", main: "DEVC", sub: "K" }
+ * parseAdtType("DEVC")   // { full: "DEVC", main: "DEVC", sub: undefined }
+ */
+declare function parseAdtType(adtType: string): {
+  full: string;
+  main: string;
+  sub?: string;
+};
+/**
+ * Get main type from ADT type
+ *
+ * @example
+ * getMainType("DEVC/K") // "DEVC"
+ * getMainType("CLAS")   // "CLAS"
+ */
+declare function getMainType(adtType: string): string;
+/** Options for registerObjectType */
+interface RegisterObjectTypeOptions {
+  /** ADT REST endpoint path segment (e.g., 'oo/classes', 'ddic/tabletypes') */
+  endpoint?: string;
+  /** How to transform the object name in URIs (default: 'lowercase') */
+  nameTransform?: NameTransform;
+  /** Optional name normalizer — e.g., strip SAPL prefix for FUGR */
+  normalizeName?: (name: string) => string;
+}
+/**
+ * Register an ADK object type
+ *
+ * @param adtType - ADT type, either main (e.g., "CLAS") or full (e.g., "TABL/DS")
+ * @param kind - ADK kind constant
+ * @param constructor - Object constructor
+ * @param options - Optional endpoint and name transform settings
+ */
+declare function registerObjectType(adtType: string, kind: AdkKind, constructor: AdkObjectConstructor, options?: RegisterObjectTypeOptions): void;
+/**
+ * Resolve ADT type to registry entry
+ *
+ * Tries full type first (e.g., "TABL/DS"), then falls back to main type (e.g., "TABL").
+ * This allows registering subtypes with different constructors/endpoints.
+ *
+ * @param adtType - Full or main ADT type (e.g., "DEVC/K" or "DEVC")
+ * @returns Registry entry or undefined if not found
+ */
+declare function resolveType(adtType: string): RegistryEntry | undefined;
+/**
+ * Resolve ADK kind to registry entry
+ *
+ * @param kind - ADK kind constant
+ * @returns Registry entry or undefined if not found
+ */
+declare function resolveKind(kind: AdkKind): RegistryEntry | undefined;
+/**
+ * Get ADK kind for ADT type
+ */
+declare function getKindForType(adtType: string): AdkKind | undefined;
+/**
+ * Get ADT main type for ADK kind
+ */
+declare function getTypeForKind(kind: AdkKind): string | undefined;
+/**
+ * Check if ADT type is registered
+ */
+declare function isTypeRegistered(adtType: string): boolean;
+/**
+ * Get all registered ADT types
+ */
+declare function getRegisteredTypes(): string[];
+/**
+ * Get all registered ADK kinds
+ */
+declare function getRegisteredKinds(): AdkKind[];
+/**
+ * Get ADT REST endpoint for a type (e.g., 'oo/classes', 'ddic/tabletypes')
+ * Checks exact type first (e.g., 'TABL/DS') before falling back to main type.
+ */
+declare function getEndpointForType(adtType: string): string | undefined;
+/**
+ * Build the full ADT object URI for a given type and name.
+ *
+ * @example
+ * getObjectUri('CLAS', 'ZCL_MY_CLASS')  // '/sap/bc/adt/oo/classes/zcl_my_class'
+ * getObjectUri('DEVC', 'ZPACKAGE')       // '/sap/bc/adt/packages/ZPACKAGE'
+ * getObjectUri('TTYP', 'ZAGE_TTYP_STRTAB') // '/sap/bc/adt/ddic/tabletypes/zage_ttyp_strtab'
+ */
+declare function getObjectUri(adtType: string, name: string): string | undefined;
+/**
+ * Normalize an object name using type-specific rules.
+ *
+ * If `adtType` is provided, applies that type's normalizer only.
+ * Otherwise, collects all possible normalized forms from every registered type.
+ *
+ * @returns Array of candidate names (always includes the original).
+ *
+ * @example
+ * normalizeObjectName('SAPLZAGE_FUGR')          // ['SAPLZAGE_FUGR', 'ZAGE_FUGR']
+ * normalizeObjectName('SAPLZAGE_FUGR', 'FUGR')  // ['ZAGE_FUGR']
+ * normalizeObjectName('ZCLAS_TEST')              // ['ZCLAS_TEST']  (no normalizer matches)
+ */
+declare function normalizeObjectName(name: string, adtType?: string): string[];
+/**
+ * Extract the root object URI from a full (possibly sub-resource) URI.
+ *
+ * SAP locks must target the object root, not sub-resources like `/source/main`.
+ * This function matches against registered endpoint prefixes and strips
+ * everything after the object name segment.
+ *
+ * @returns The root object URI, or the original URI unchanged if no endpoint matches.
+ *
+ * @example
+ * getObjectRootUri('/sap/bc/adt/functions/groups/zage_fugr/source/main')
+ *   // → '/sap/bc/adt/functions/groups/zage_fugr'
+ * getObjectRootUri('/sap/bc/adt/oo/classes/zcl_test/includes/testclasses')
+ *   // → '/sap/bc/adt/oo/classes/zcl_test'
+ * getObjectRootUri('/sap/bc/adt/oo/classes/zcl_test')
+ *   // → '/sap/bc/adt/oo/classes/zcl_test'  (already root)
+ */
+declare function getObjectRootUri(uri: string): string;
+/**
+ * Known ADT type to ADK kind mappings
+ *
+ * Repository Objects:
+ * - DEVC → Package
+ * - CLAS → Class
+ * - INTF → Interface
+ * - FUGR → FunctionGroup
+ * - FUNC → FunctionModule
+ * - PROG → Program
+ * - INCL → Include
+ *
+ * Data Dictionary:
+ * - TABL → Table
+ * - STRU → Structure (actually TABL with different category)
+ * - DTEL → DataElement
+ * - DOMA → Domain
+ * - TTYP → TableType
+ *
+ * Other:
+ * - MSAG → MessageClass
+ * - ENHS → EnhancementSpot
+ *
+ * CTS:
+ * - (Transport requests/tasks use different identification)
+ */
+declare const ADT_TYPE_MAPPINGS: {
+  readonly DEVC: "Package";
+  readonly CLAS: "Class";
+  readonly INTF: "Interface";
+  readonly FUGR: "FunctionGroup";
+  readonly FUNC: "FunctionModule";
+  readonly PROG: "Program";
+  readonly INCL: "Include";
+  readonly TABL: "Table";
+  readonly DTEL: "DataElement";
+  readonly DOMA: "Domain";
+  readonly TTYP: "TableType";
+  readonly MSAG: "MessageClass";
+  readonly ENHS: "EnhancementSpot";
+};
+//#endregion
+export { ADT_TYPE_MAPPINGS, type AbapClass, type AbapFunctionGroup, type AbapFunctionModule, type AbapInclude, type AbapInterface, type AbapObject, type AbapPackage, type AbapProgram, type ActivationResult, AdkBadi, AdkBehaviorDefinition, AdkClass, type AdkContext, type AdkContract, AdkDataElement, AdkDclSource, AdkDdlSource, AdkDomain, type AdkFactory, AdkFunctionGroup, AdkFunctionModule, AdkGenericObject, AdkInclude, AdkInterface, AdkKind, AdkMainObject, type AdkMainObjectData, AdkObject, type AdkObjectData, type AdkObjectForKind, AdkObjectSet, AdkPackage, AdkProgram, AdkServiceBinding, AdkServiceDefinition, AdkStructure, AdkTable, AdkTableType, AdkTransport, AdkTransportRequest as AdkTransportItem, AdkTransportRequest, AdkTransportObject, AdkTransportObjectRef, AdkTransportTask, AdkTransportTaskRef, type AdtClient, type AdtContracts, type AdtObjectReference, type ApplicationComponent, type AtomLink, type BulkActivateOptions, type BulkSaveOptions, type BulkSaveResult, Class, type ClassCategory, type ClassInclude, type ClassIncludeType, type ClassResponse, type ClassVisibility, type ClassXml, DataElement, type DataElementResponse, type DataElementXml, Domain, type DomainResponse, type DomainXml, EnhancementSpot, FunctionGroup, type FunctionGroupResponse, type FunctionGroupXml, FunctionModule, type FunctionModuleResponse, type FunctionModuleXml, Include, type IncludeResponse, type IncludeXml, Interface, type InterfaceResponse, type InterfaceXml, type LockEntry, type LockHandle, type LockRegistry, type LockService, type LockStore, MergedTransportView, MessageClass, type NameTransform, type ObjectReference, Package, type PackageAttributes, type PackageResponse, type PackageType, type PackageXml, Program, type ProgramResponse, type ProgramXml, type RegisterObjectTypeOptions, type ReleaseResult, type ResolvedTransportObjects, type SaveOptions, type SoftwareComponent, Structure, Table, TableType, type TableTypeResponse, type TableTypeXml, type TableXml, type TransportConfig, type TransportCreateOptions, type TransportData, type TransportGetResponse, type TransportGetResponse as TransportResponse, type TransportLayer, type TransportObject, type TransportObjectData, type TransportObjectSelector, TransportRequest, type TransportRequestData, type TransportStatus, type TransportTask, type TransportTaskData, type TransportType, type TransportUpdateOptions, clearConfigCache, createAdk, createAdkContract, createAdkFactory, createLockService, getEndpointForType, getGlobalContext, getKindForType, getMainType, getObjectRootUri, getObjectUri, getRegisteredKinds, getRegisteredTypes, getTypeForKind, initializeAdk, isAdkInitialized, isTypeRegistered, matchesSelector, normalizeObjectName, parseAdtType, parseXmlIdentity, registerObjectType, resetAdk, resolveKind, resolveTransportObjects, resolveType, tryGetGlobalContext };
+//# sourceMappingURL=index.d.mts.map