@mcp-abap-adt/core 4.7.1 → 4.8.2

package/dist/src/handlers/compact/high/handleHandlerUnlock.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerUnlock = handleHandlerUnlock;
+const handleUnlockObject_1 = require("../../common/low/handleUnlockObject");
+const compactLifecycleUtils_1 = require("./compactLifecycleUtils");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerUnlock',
+    available_in: ['onprem', 'cloud'],
+    description: 'Unlock operation. object_type required: CLASS(object_name*, lock_handle*, session_id*), PROGRAM(object_name*, lock_handle*, session_id*), INTERFACE(object_name*, lock_handle*, session_id*), FUNCTION_GROUP(object_name*, lock_handle*, session_id*), FUNCTION_MODULE(object_name*, lock_handle*, session_id*), TABLE(object_name*, lock_handle*, session_id*), STRUCTURE(object_name*, lock_handle*, session_id*), VIEW(object_name*, lock_handle*, session_id*), DOMAIN(object_name*, lock_handle*, session_id*), DATA_ELEMENT(object_name*, lock_handle*, session_id*), PACKAGE(object_name*, lock_handle*, session_id*), BEHAVIOR_DEFINITION(object_name*, lock_handle*, session_id*), BEHAVIOR_IMPLEMENTATION(object_name*, lock_handle*, session_id*), METADATA_EXTENSION(object_name*, lock_handle*, session_id*).',
+    inputSchema: compactSchemas_1.compactUnlockSchema,
+};
+async function handleHandlerUnlock(context, args) {
+    const lowType = (0, compactLifecycleUtils_1.toLowObjectType)(args.object_type);
+    if (!lowType) {
+        throw new Error(`Unlock is not supported for object_type: ${args.object_type}`);
+    }
+    return (0, handleUnlockObject_1.handleUnlockObject)(context, {
+        object_name: args.object_name,
+        object_type: lowType,
+        lock_handle: args.lock_handle,
+        session_id: args.session_id,
+        session_state: args.session_state,
+    });
+}
+//# sourceMappingURL=handleHandlerUnlock.js.map

package/dist/src/handlers/compact/high/handleHandlerUnlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUnlock.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerUnlock.ts"],"names":[],"mappings":";;;AA0BA,kDAkBC;AA3CD,4EAAyE;AACzE,mEAA0D;AAE1D,qDAAuD;AAE1C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,eAAe;IACrB,YAAY,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAU;IAC1C,WAAW,EACT,4xBAA4xB;IAC9xB,WAAW,EAAE,oCAAmB;CACxB,CAAC;AAcJ,KAAK,UAAU,mBAAmB,CACvC,OAAuB,EACvB,IAAuB;IAEvB,MAAM,OAAO,GAAG,IAAA,uCAAe,EAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,4CAA4C,IAAI,CAAC,WAAW,EAAE,CAC/D,CAAC;IACJ,CAAC;IAED,OAAO,IAAA,uCAAkB,EAAC,OAAO,EAAE;QACjC,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,OAAO;QACpB,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;KAClC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/handlers/compact/high/handleHandlerUpdate.d.ts

@@ -0,0 +1,110 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerUpdate";
+    readonly available_in: readonly ["onprem", "cloud"];
+    readonly description: "Update operation. object_type required: PACKAGE(package_name*), DOMAIN(domain_name*), DATA_ELEMENT(data_element_name*), TABLE(table_name*), STRUCTURE(structure_name*), VIEW(view_name*), SERVICE_DEFINITION(service_definition_name*), SERVICE_BINDING(service_binding_name*), CLASS(class_name*), LOCAL_TEST_CLASS(class_name*), LOCAL_TYPES(class_name*), LOCAL_DEFINITIONS(class_name*), LOCAL_MACROS(class_name*), PROGRAM(program_name*), INTERFACE(interface_name*), FUNCTION_GROUP(function_group_name*), FUNCTION_MODULE(function_module_name*, function_group_name*), BEHAVIOR_DEFINITION(behavior_definition_name*), BEHAVIOR_IMPLEMENTATION(behavior_implementation_name*), METADATA_EXTENSION(metadata_extension_name*), UNIT_TEST(run_id*), CDS_UNIT_TEST(run_id*).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly class_name: {
+                readonly type: "string";
+                readonly description: "ABAP class name.";
+            };
+            readonly program_name: {
+                readonly type: "string";
+                readonly description: "ABAP program name.";
+            };
+            readonly domain_name: {
+                readonly type: "string";
+                readonly description: "ABAP domain name.";
+            };
+            readonly function_module_name: {
+                readonly type: "string";
+                readonly description: "ABAP function module name.";
+            };
+            readonly function_group_name: {
+                readonly type: "string";
+                readonly description: "ABAP function group name.";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "ABAP package name.";
+            };
+            readonly source_code: {
+                readonly type: "string";
+                readonly description: "ABAP source code payload.";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request id (if required by system).";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate object after update.";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Human-readable object description.";
+            };
+            readonly datatype: {
+                readonly type: "string";
+                readonly description: "ABAP data type.";
+            };
+            readonly length: {
+                readonly type: "number";
+                readonly description: "Length for typed artifacts.";
+            };
+            readonly decimals: {
+                readonly type: "number";
+                readonly description: "Decimal places.";
+            };
+            readonly conversion_exit: {
+                readonly type: "string";
+                readonly description: "Conversion exit name.";
+            };
+            readonly lowercase: {
+                readonly type: "boolean";
+                readonly description: "Allow lowercase values (domain setting).";
+            };
+            readonly sign_exists: {
+                readonly type: "boolean";
+                readonly description: "Allow signed values (domain setting).";
+            };
+            readonly value_table: {
+                readonly type: "string";
+                readonly description: "Foreign key value table.";
+            };
+            readonly fixed_values: {
+                readonly type: "array";
+                readonly description: "Domain fixed values list.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly low: {
+                            readonly type: "string";
+                            readonly description: "Fixed value key.";
+                        };
+                        readonly text: {
+                            readonly type: "string";
+                            readonly description: "Fixed value text.";
+                        };
+                    };
+                    readonly required: readonly ["low", "text"];
+                };
+            };
+        };
+        readonly required: readonly ["object_type"];
+    };
+};
+type HandlerUpdateArgs = {
+    object_type: CompactObjectType;
+} & Record<string, unknown>;
+export declare function handleHandlerUpdate(context: HandlerContext, args: HandlerUpdateArgs): Promise<unknown>;
+export {};
+//# sourceMappingURL=handleHandlerUpdate.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUpdate.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerUpdate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,KAAK,iBAAiB,GAAG;IAAE,WAAW,EAAE,iBAAiB,CAAA;CAAE,GAAG,MAAM,CAClE,MAAM,EACN,OAAO,CACR,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,iBAAiB,oBAGxB"}

package/dist/src/handlers/compact/high/handleHandlerUpdate.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerUpdate = handleHandlerUpdate;
+const compactRouter_1 = require("./compactRouter");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerUpdate',
+    available_in: ['onprem', 'cloud'],
+    description: 'Update operation. object_type required: PACKAGE(package_name*), DOMAIN(domain_name*), DATA_ELEMENT(data_element_name*), TABLE(table_name*), STRUCTURE(structure_name*), VIEW(view_name*), SERVICE_DEFINITION(service_definition_name*), SERVICE_BINDING(service_binding_name*), CLASS(class_name*), LOCAL_TEST_CLASS(class_name*), LOCAL_TYPES(class_name*), LOCAL_DEFINITIONS(class_name*), LOCAL_MACROS(class_name*), PROGRAM(program_name*), INTERFACE(interface_name*), FUNCTION_GROUP(function_group_name*), FUNCTION_MODULE(function_module_name*, function_group_name*), BEHAVIOR_DEFINITION(behavior_definition_name*), BEHAVIOR_IMPLEMENTATION(behavior_implementation_name*), METADATA_EXTENSION(metadata_extension_name*), UNIT_TEST(run_id*), CDS_UNIT_TEST(run_id*).',
+    inputSchema: compactSchemas_1.compactUpdateSchema,
+};
+async function handleHandlerUpdate(context, args) {
+    return (0, compactRouter_1.routeCompactOperation)(context, 'update', args);
+}
+//# sourceMappingURL=handleHandlerUpdate.js.map

package/dist/src/handlers/compact/high/handleHandlerUpdate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUpdate.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerUpdate.ts"],"names":[],"mappings":";;;AAkBA,kDAKC;AArBD,mDAAwD;AACxD,qDAAuD;AAE1C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,eAAe;IACrB,YAAY,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAU;IAC1C,WAAW,EACT,mvBAAmvB;IACrvB,WAAW,EAAE,oCAAmB;CACxB,CAAC;AAOJ,KAAK,UAAU,mBAAmB,CACvC,OAAuB,EACvB,IAAuB;IAEvB,OAAO,IAAA,qCAAqB,EAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AACxD,CAAC"}

package/dist/src/handlers/compact/high/handleHandlerValidate.d.ts

@@ -0,0 +1,98 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerValidate";
+    readonly available_in: readonly ["onprem", "cloud"];
+    readonly description: "Validate before create only. object_type required: CLASS(object_name*), PROGRAM(object_name*), INTERFACE(object_name*), FUNCTION_GROUP(object_name*), FUNCTION_MODULE(object_name*), TABLE(object_name*), STRUCTURE(object_name*), VIEW(object_name*), DOMAIN(object_name*), DATA_ELEMENT(object_name*), PACKAGE(object_name*), BEHAVIOR_DEFINITION(object_name*), BEHAVIOR_IMPLEMENTATION(object_name*), METADATA_EXTENSION(object_name*), SERVICE_BINDING(object_name*=service_binding_name*, service_definition_name*).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: readonly ["CLASS", "PROGRAM", "INTERFACE", "FUNCTION_GROUP", "FUNCTION_MODULE", "TABLE", "STRUCTURE", "VIEW", "DOMAIN", "DATA_ELEMENT", "PACKAGE", "BEHAVIOR_DEFINITION", "BEHAVIOR_IMPLEMENTATION", "METADATA_EXTENSION", "SERVICE_BINDING"];
+                readonly description: "Object type to validate before create. Supported: CLASS, PROGRAM, INTERFACE, FUNCTION_GROUP, FUNCTION_MODULE, TABLE, STRUCTURE, VIEW, DOMAIN, DATA_ELEMENT, PACKAGE, BEHAVIOR_DEFINITION, BEHAVIOR_IMPLEMENTATION, METADATA_EXTENSION, SERVICE_BINDING.";
+            };
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Required object name. For SERVICE_BINDING this is the service binding name.";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Optional package context for validation (especially for create scenarios).";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Optional object description used during validation.";
+            };
+            readonly behavior_definition: {
+                readonly type: "string";
+                readonly description: "Optional behavior definition name, used when validating behavior implementation.";
+            };
+            readonly root_entity: {
+                readonly type: "string";
+                readonly description: "Optional CDS root entity name, used for behavior-related validation.";
+            };
+            readonly implementation_type: {
+                readonly type: "string";
+                readonly description: "Optional implementation type, used for behavior implementation validation.";
+            };
+            readonly service_definition_name: {
+                readonly type: "string";
+                readonly description: "Required when object_type=SERVICE_BINDING. Service definition paired with the binding.";
+            };
+            readonly service_binding_version: {
+                readonly type: "string";
+                readonly description: "Optional service binding version for SERVICE_BINDING.";
+            };
+            readonly session_id: {
+                readonly type: "string";
+                readonly description: "Optional ADT session id for stateful validation flow.";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly description: "Optional ADT session state container (cookies/CSRF) for stateful validation flow.";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                        readonly description: "Serialized Cookie header to reuse server session.";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                        readonly description: "CSRF token to reuse server session.";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                        readonly description: "Cookie key/value map to reuse server session.";
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["object_type", "object_name"];
+    };
+};
+type HandlerValidateArgs = {
+    object_type: CompactObjectType;
+    object_name: string;
+    package_name?: string;
+    description?: string;
+    behavior_definition?: string;
+    root_entity?: string;
+    implementation_type?: string;
+    service_definition_name?: string;
+    service_binding_version?: string;
+    session_id?: string;
+    session_state?: {
+        cookies?: string;
+        csrf_token?: string;
+        cookie_store?: Record<string, string>;
+    };
+};
+export declare function handleHandlerValidate(context: HandlerContext, args: HandlerValidateArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerValidate.d.ts.map

package/dist/src/handlers/compact/high/handleHandlerValidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerValidate.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerValidate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB,CAAC;AAEX,KAAK,mBAAmB,GAAG;IACzB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACvC,CAAC;CACH,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,mBAAmB;;;;;;GA8B1B"}

package/dist/src/handlers/compact/high/handleHandlerValidate.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerValidate = handleHandlerValidate;
+const handleValidateObject_1 = require("../../common/low/handleValidateObject");
+const handleValidateServiceBinding_1 = require("../../service_binding/high/handleValidateServiceBinding");
+const compactLifecycleUtils_1 = require("./compactLifecycleUtils");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerValidate',
+    available_in: ['onprem', 'cloud'],
+    description: 'Validate before create only. object_type required: CLASS(object_name*), PROGRAM(object_name*), INTERFACE(object_name*), FUNCTION_GROUP(object_name*), FUNCTION_MODULE(object_name*), TABLE(object_name*), STRUCTURE(object_name*), VIEW(object_name*), DOMAIN(object_name*), DATA_ELEMENT(object_name*), PACKAGE(object_name*), BEHAVIOR_DEFINITION(object_name*), BEHAVIOR_IMPLEMENTATION(object_name*), METADATA_EXTENSION(object_name*), SERVICE_BINDING(object_name*=service_binding_name*, service_definition_name*).',
+    inputSchema: compactSchemas_1.compactValidateSchema,
+};
+async function handleHandlerValidate(context, args) {
+    if (args.object_type === 'SERVICE_BINDING') {
+        return (0, handleValidateServiceBinding_1.handleValidateServiceBinding)(context, {
+            service_binding_name: args.object_name,
+            service_definition_name: args.service_definition_name,
+            service_binding_version: args.service_binding_version,
+            package_name: args.package_name,
+            description: args.description,
+        });
+    }
+    const lowType = (0, compactLifecycleUtils_1.toLowObjectType)(args.object_type);
+    if (!lowType) {
+        throw new Error(`Validate is not supported for object_type: ${args.object_type}`);
+    }
+    return (0, handleValidateObject_1.handleValidateObject)(context, {
+        object_name: args.object_name,
+        object_type: lowType,
+        package_name: args.package_name,
+        description: args.description,
+        behavior_definition: args.behavior_definition,
+        root_entity: args.root_entity,
+        implementation_type: args.implementation_type,
+        session_id: args.session_id,
+        session_state: args.session_state,
+    });
+}
+//# sourceMappingURL=handleHandlerValidate.js.map

package/dist/src/handlers/compact/high/handleHandlerValidate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerValidate.js","sourceRoot":"","sources":["../../../../../src/handlers/compact/high/handleHandlerValidate.ts"],"names":[],"mappings":";;;AAiCA,sDAgCC;AAhED,gFAA6E;AAC7E,0GAAuG;AACvG,mEAA0D;AAE1D,qDAAyD;AAE5C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,YAAY,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAU;IAC1C,WAAW,EACT,4fAA4f;IAC9f,WAAW,EAAE,sCAAqB;CAC1B,CAAC;AAoBJ,KAAK,UAAU,qBAAqB,CACzC,OAAuB,EACvB,IAAyB;IAEzB,IAAI,IAAI,CAAC,WAAW,KAAK,iBAAiB,EAAE,CAAC;QAC3C,OAAO,IAAA,2DAA4B,EAAC,OAAO,EAAE;YAC3C,oBAAoB,EAAE,IAAI,CAAC,WAAW;YACtC,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC,CAAC;IACL,CAAC;IAED,MAAM,OAAO,GAAG,IAAA,uCAAe,EAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,8CAA8C,IAAI,CAAC,WAAW,EAAE,CACjE,CAAC;IACJ,CAAC;IAED,OAAO,IAAA,2CAAoB,EAAC,OAAO,EAAE;QACnC,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,OAAO;QACpB,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;QAC7C,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;QAC7C,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;KAClC,CAAC,CAAC;AACL,CAAC"}

package/dist/src/handlers/data_element/high/handleCreateDataElement.d.ts

@@ -0,0 +1,123 @@
+/**
+ * CreateDataElement Handler - ABAP Data Element Creation via ADT API
+ *
+ * Uses DataElementBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: create -> activate -> verify
+ */
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateDataElement";
+    readonly available_in: readonly ["onprem", "cloud"];
+    readonly description: "Create a new ABAP data element in SAP system with all required steps: create, activate, and verify.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly data_element_name: {
+                readonly type: "string";
+                readonly description: "Data element name (e.g., ZZ_E_TEST_001). Must follow SAP naming conventions.";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Data element description. If not provided, data_element_name will be used.";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name (e.g., ZOK_LOCAL, $TMP for local objects)";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number (e.g., E19K905635). Required for transportable packages.";
+            };
+            readonly data_type: {
+                readonly type: "string";
+                readonly description: "Data type (e.g., CHAR, NUMC) or domain name when type_kind is 'domain'.";
+                readonly default: "CHAR";
+            };
+            readonly length: {
+                readonly type: "number";
+                readonly description: "Data type length. Usually inherited from domain.";
+                readonly default: 100;
+            };
+            readonly decimals: {
+                readonly type: "number";
+                readonly description: "Decimal places. Usually inherited from domain.";
+                readonly default: 0;
+            };
+            readonly short_label: {
+                readonly type: "string";
+                readonly description: "Short field label (max 10 chars). Applied during update step after creation.";
+            };
+            readonly medium_label: {
+                readonly type: "string";
+                readonly description: "Medium field label (max 20 chars). Applied during update step after creation.";
+            };
+            readonly long_label: {
+                readonly type: "string";
+                readonly description: "Long field label (max 40 chars). Applied during update step after creation.";
+            };
+            readonly heading_label: {
+                readonly type: "string";
+                readonly description: "Heading field label (max 55 chars). Applied during update step after creation.";
+            };
+            readonly type_kind: {
+                readonly type: "string";
+                readonly description: "Type kind: 'domain' (default), 'predefinedAbapType', 'refToPredefinedAbapType', 'refToDictionaryType', 'refToClifType'. If not specified, defaults to 'domain'.";
+                readonly enum: readonly ["domain", "predefinedAbapType", "refToPredefinedAbapType", "refToDictionaryType", "refToClifType"];
+                readonly default: "domain";
+            };
+            readonly type_name: {
+                readonly type: "string";
+                readonly description: "Type name: domain name (when type_kind is 'domain'), data element name (when type_kind is 'refToDictionaryType'), or class name (when type_kind is 'refToClifType')";
+            };
+            readonly search_help: {
+                readonly type: "string";
+                readonly description: "Search help name. Applied during update step after creation.";
+            };
+            readonly search_help_parameter: {
+                readonly type: "string";
+                readonly description: "Search help parameter. Applied during update step after creation.";
+            };
+            readonly set_get_parameter: {
+                readonly type: "string";
+                readonly description: "Set/Get parameter ID. Applied during update step after creation.";
+            };
+        };
+        readonly required: readonly ["data_element_name", "package_name"];
+    };
+};
+interface DataElementArgs {
+    data_element_name: string;
+    description?: string;
+    package_name: string;
+    transport_request?: string;
+    data_type?: string;
+    length?: number;
+    decimals?: number;
+    short_label?: string;
+    medium_label?: string;
+    long_label?: string;
+    heading_label?: string;
+    type_kind?: 'domain' | 'predefinedAbapType' | 'refToPredefinedAbapType' | 'refToDictionaryType' | 'refToClifType';
+    type_name?: string;
+    search_help?: string;
+    search_help_parameter?: string;
+    set_get_parameter?: string;
+    activate?: boolean;
+}
+/**
+ * Main handler for CreateDataElement MCP tool
+ *
+ * Uses DataElementBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleCreateDataElement(context: HandlerContext, args: DataElementArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleCreateDataElement.d.ts.map

package/dist/src/handlers/data_element/high/handleCreateDataElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateDataElement.d.ts","sourceRoot":"","sources":["../../../../../src/handlers/data_element/high/handleCreateDataElement.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAUvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGlB,CAAC;AAEX,UAAU,eAAe;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EACN,QAAQ,GACR,oBAAoB,GACpB,yBAAyB,GACzB,qBAAqB,GACrB,eAAe,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,eAAe;;;;;;GA4LtB"}