@mcp-abap-adt/core 1.4.1

package/bin/unlock-test-objects.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+/**
+ * Utility script to unlock all test objects from .locks/active-locks.json
+ *
+ * Usage:
+ *   node bin/unlock-test-objects.js [options]
+ *   adt-unlock-objects [options]
+ *
+ * Options:
+ *   --locks-dir <path>    Lock registry directory (default: .locks)
+ *   --env <path>          Path to .env file (default: .env)
+ *   -h, --help            Show help message
+ */
+
+const path = require('path');
+const fs = require('fs');
+const dotenv = require('dotenv');
+
+// Show help if requested
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  console.log(`
+🔓 Unlock Test Objects - Utility to unlock all objects from lock registry
+
+Usage:
+  node bin/unlock-test-objects.js [options]
+  adt-unlock-objects [options]
+
+Options:
+  --locks-dir <path>    Lock registry directory (default: .locks)
+  --env <path>          Path to .env file (default: .env)
+  -h, --help            Show this help message
+
+Description:
+  This utility reads all active locks from .locks/active-locks.json and attempts
+  to unlock them on the SAP server. After successful unlock, locks are removed
+  from the registry.
+
+  The script uses JWT auto-refresh if refresh credentials are available in .env.
+
+Environment Variables (from .env):
+  SAP_URL              - SAP system URL
+  SAP_CLIENT           - SAP client (optional)
+  SAP_AUTH_TYPE        - Authentication type: basic, jwt, xsuaa
+  SAP_JWT_TOKEN        - JWT token (for jwt/xsuaa auth)
+  SAP_REFRESH_TOKEN     - Refresh token (optional, for auto-refresh)
+  SAP_UAA_URL          - UAA URL (optional, for auto-refresh)
+  SAP_UAA_CLIENT_ID    - UAA client ID (optional, for auto-refresh)
+  SAP_UAA_CLIENT_SECRET - UAA client secret (optional, for auto-refresh)
+  SAP_USERNAME         - Username (for basic auth)
+  SAP_PASSWORD         - Password (for basic auth)
+`);
+  process.exit(0);
+}
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    locksDir: '.locks',
+    envPath: '.env'
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--locks-dir' && i + 1 < args.length) {
+      options.locksDir = args[++i];
+    } else if (arg === '--env' && i + 1 < args.length) {
+      options.envPath = args[++i];
+    }
+  }
+
+  return options;
+}
+
+// Load environment
+const options = parseArgs();
+const envPath = process.env.MCP_ENV_PATH || path.resolve(__dirname, '..', options.envPath);
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+const { createAbapConnection } = require('@mcp-abap-adt/connection');
+const { LockStateManager } = require('../src/utils/lockStateManager');
+const { unlockClass } = require('@mcp-abap-adt/adt-clients/core/class/unlock');
+const { unlockInterface } = require('@mcp-abap-adt/adt-clients/core/interface/unlock');
+const { unlockProgram } = require('@mcp-abap-adt/adt-clients/core/program/unlock');
+const { unlockFunctionModule } = require('@mcp-abap-adt/adt-clients/core/functionModule/unlock');
+const { unlockDomain } = require('@mcp-abap-adt/adt-clients/core/domain/unlock');
+const { unlockDataElement } = require('@mcp-abap-adt/adt-clients/core/dataElement/unlock');
+const { unlockDDLS } = require('@mcp-abap-adt/adt-clients/core/view/unlock');
+const { unlockStructure } = require('@mcp-abap-adt/adt-clients/core/structure/unlock');
+const { unlockTable } = require('@mcp-abap-adt/adt-clients/core/table/unlock');
+const { unlockPackage } = require('@mcp-abap-adt/adt-clients/core/package/unlock');
+
+function getConfig() {
+  const rawUrl = process.env.SAP_URL;
+  const url = rawUrl ? rawUrl.split('#')[0].trim() : rawUrl;
+  const rawClient = process.env.SAP_CLIENT;
+  const client = rawClient ? rawClient.split('#')[0].trim() : rawClient;
+  const rawAuthType = process.env.SAP_AUTH_TYPE || 'basic';
+  const authType = rawAuthType.split('#')[0].trim();
+
+  if (!url || !/^https?:\/\//.test(url)) {
+    throw new Error(`Missing or invalid SAP_URL: ${url}`);
+  }
+
+  const config = {
+    url,
+    authType: authType === 'xsuaa' ? 'jwt' : authType,
+  };
+
+  if (client) {
+    config.client = client;
+  }
+
+  if (authType === 'jwt' || authType === 'xsuaa') {
+    const jwtToken = process.env.SAP_JWT_TOKEN;
+    if (!jwtToken) {
+      throw new Error('Missing SAP_JWT_TOKEN for JWT authentication');
+    }
+    config.jwtToken = jwtToken;
+
+    // Add refresh credentials if available (for auto-refresh)
+    if (process.env.SAP_REFRESH_TOKEN) {
+      config.refreshToken = process.env.SAP_REFRESH_TOKEN;
+    }
+    if (process.env.SAP_UAA_URL) {
+      config.uaaUrl = process.env.SAP_UAA_URL;
+    }
+    if (process.env.SAP_UAA_CLIENT_ID) {
+      config.uaaClientId = process.env.SAP_UAA_CLIENT_ID;
+    }
+    if (process.env.SAP_UAA_CLIENT_SECRET) {
+      config.uaaClientSecret = process.env.SAP_UAA_CLIENT_SECRET;
+    }
+  } else {
+    const username = process.env.SAP_USERNAME;
+    const password = process.env.SAP_PASSWORD;
+    if (!username || !password) {
+      throw new Error('Missing SAP_USERNAME or SAP_PASSWORD for basic authentication');
+    }
+    config.username = username;
+    config.password = password;
+  }
+
+  return config;
+}
+
+/**
+ * Unlock object based on type
+ */
+async function unlockObject(connection, lock) {
+  const { objectType, objectName, functionGroupName, lockHandle, sessionId } = lock;
+
+  switch (objectType) {
+    case 'class':
+      return await unlockClass(connection, objectName, lockHandle, sessionId);
+    case 'interface':
+      return await unlockInterface(connection, objectName, lockHandle, sessionId);
+    case 'program':
+      return await unlockProgram(connection, objectName, lockHandle, sessionId);
+    case 'fm':
+      if (!functionGroupName) {
+        throw new Error(`Function group name required for FM: ${objectName}`);
+      }
+      return await unlockFunctionModule(connection, functionGroupName, objectName, lockHandle, sessionId);
+    case 'domain':
+      return await unlockDomain(connection, objectName, lockHandle, sessionId);
+    case 'dataElement':
+      return await unlockDataElement(connection, objectName, lockHandle, sessionId);
+    case 'view':
+      return await unlockDDLS(connection, objectName, lockHandle, sessionId);
+    case 'structure':
+      return await unlockStructure(connection, objectName, lockHandle, sessionId);
+    case 'table':
+      return await unlockTable(connection, objectName, lockHandle, sessionId);
+    case 'package':
+      return await unlockPackage(connection, objectName, lockHandle, sessionId);
+    default:
+      throw new Error(`Unknown object type: ${objectType}`);
+  }
+}
+
+function formatLockInfo(lock) {
+  const objectId = lock.functionGroupName
+    ? `${lock.functionGroupName}/${lock.objectName}`
+    : lock.objectName;
+  return `${lock.objectType.toUpperCase()}: ${objectId}`;
+}
+
+async function unlockTestObjects() {
+  try {
+    const config = getConfig();
+    const connection = createAbapConnection(config, console);
+
+    // Load lock registry
+    const lockManager = new LockStateManager(options.locksDir);
+    const locks = lockManager.getAllLocks();
+
+    if (locks.length === 0) {
+      console.log('✅ No active locks found in registry');
+      return;
+    }
+
+    console.log(`🔓 Found ${locks.length} lock(s) in registry\n`);
+
+    let successCount = 0;
+    let failCount = 0;
+
+    // Connection will auto-connect on first request (with JWT refresh if needed)
+    for (const lock of locks) {
+      try {
+        const lockInfo = formatLockInfo(lock);
+        console.log(`Attempting to unlock ${lockInfo}...`);
+
+        await unlockObject(connection, lock);
+
+        // Remove from registry after successful unlock
+        lockManager.removeLock(lock.objectType, lock.objectName, lock.functionGroupName);
+
+        console.log(`✅ Unlocked: ${lockInfo}\n`);
+        successCount++;
+      } catch (error) {
+        const lockInfo = formatLockInfo(lock);
+        console.log(`❌ Failed to unlock ${lockInfo}: ${error.message}\n`);
+        failCount++;
+
+        // Don't remove from registry if unlock failed - might be locked by another session
+        // User can manually clean up later
+      }
+    }
+
+    console.log('\n📊 Summary:');
+    console.log(`   ✅ Successfully unlocked: ${successCount}`);
+    console.log(`   ❌ Failed to unlock: ${failCount}`);
+
+    if (failCount > 0) {
+      console.log('\n💡 Note: Failed unlocks may be locked by another session or already unlocked.');
+      console.log('   You can check with: adt-manage-locks list');
+    }
+
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+unlockTestObjects();

package/dist/bin/help.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Help text for MCP ABAP ADT Server v2
+ */
+export declare function showHelp(): void;
+export declare function showVersion(): void;
+//# sourceMappingURL=help.d.ts.map

package/dist/bin/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../src/bin/help.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,QAAQ,IAAI,IAAI,CA8C/B;AAED,wBAAgB,WAAW,IAAI,IAAI,CAIlC"}

package/dist/bin/help.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Help text for MCP ABAP ADT Server v2
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showHelp = showHelp;
+exports.showVersion = showVersion;
+function showHelp() {
+    // From bin/help.js, package.json is in ../package.json
+    const pkg = require('../package.json');
+    console.log(`
+MCP ABAP ADT Server v2 v${pkg.version}
+
+Usage:
+  mcp-abap-adt-v2 [options]
+
+Options:
+  --mcp=<destination>       MCP destination name (required)
+                            Example: --mcp=TRIAL
+  --transport=<type>        Transport type: stdio (default), sse, http
+  --http-port=<port>        HTTP server port (default: 3000)
+  --sse-port=<port>         SSE server port (default: 3001)
+  --http-host=<host>        HTTP server host (default: 127.0.0.1 for local only, use 0.0.0.0 for all interfaces)
+                            Security: When listening on 0.0.0.0, client must provide all connection headers
+  --sse-host=<host>         SSE server host (default: 127.0.0.1 for local only, use 0.0.0.0 for all interfaces)
+                            Security: When listening on 0.0.0.0, client must provide all connection headers
+  --help, -h                Show this help message
+  --version, -v             Show version number
+
+Environment Variables:
+  MCP_HTTP_PORT             HTTP server port (default: 3000)
+  MCP_SSE_PORT              SSE server port (default: 3001)
+  MCP_HTTP_HOST             HTTP server host (default: 127.0.0.1)
+  MCP_SSE_HOST              SSE server host (default: 127.0.0.1)
+  AUTH_BROKER_PATH          Custom paths for service keys and sessions
+                            Unix: colon-separated (e.g., /path1:/path2)
+                            Windows: semicolon-separated (e.g., C:\\path1;C:\\path2)
+  AUTH_LOG_LEVEL            Handler logger level: error|warn|info|debug (default: info)
+
+Examples:
+  mcp-abap-adt-v2 --mcp=TRIAL                                    # Default stdio mode
+  mcp-abap-adt-v2 --mcp=TRIAL --transport=sse                   # SSE mode on port 3001
+  mcp-abap-adt-v2 --mcp=TRIAL --transport=sse --sse-port=8080    # SSE mode on custom port
+  mcp-abap-adt-v2 --mcp=TRIAL --transport=http                   # HTTP mode on port 3000
+  mcp-abap-adt-v2 --mcp=TRIAL --transport=http --http-port=8080 # HTTP mode on custom port
+  mcp-abap-adt-v2 --mcp=TRIAL --transport=http --http-host=0.0.0.0 # HTTP mode accepting all interfaces
+
+Notes:
+  - v2 server uses Dependency Injection architecture
+  - All transports support LOCAL mode (service keys + AuthBroker)
+  - HTTP and SSE transports support REMOTE mode (client-provided headers) when host=0.0.0.0
+  - Authentication: When starting, if authentication is required, browser will open automatically
+`);
+}
+function showVersion() {
+    // From bin/help.js, package.json is in ../package.json
+    const pkg = require('../package.json');
+    console.log(`mcp-abap-adt-v2 v${pkg.version}`);
+}

package/dist/bin/mcp-abap-adt-v2.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * MCP ABAP ADT Server v2 Entry Point
+ *
+ * Main entry point for v2 server architecture
+ * Compiles to dist/bin/mcp-abap-adt-v2.js
+ */
+export {};
+//# sourceMappingURL=mcp-abap-adt-v2.d.ts.map

package/dist/bin/mcp-abap-adt-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-abap-adt-v2.d.ts","sourceRoot":"","sources":["../../src/bin/mcp-abap-adt-v2.ts"],"names":[],"mappings":";AACA;;;;;GAKG"}

package/dist/bin/mcp-abap-adt-v2.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * MCP ABAP ADT Server v2 Entry Point
+ *
+ * Main entry point for v2 server architecture
+ * Compiles to dist/bin/mcp-abap-adt-v2.js
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const McpServer_js_1 = require("../lib/servers/v2/server/McpServer.js");
+const StdioTransport_js_1 = require("../lib/servers/v2/transports/StdioTransport.js");
+const SseTransport_js_1 = require("../lib/servers/v2/transports/SseTransport.js");
+const StreamableHttpTransport_js_1 = require("../lib/servers/v2/transports/StreamableHttpTransport.js");
+const SessionManager_js_1 = require("../lib/servers/v2/session/SessionManager.js");
+const ProtocolHandler_js_1 = require("../lib/servers/v2/protocol/ProtocolHandler.js");
+const CompositeHandlersRegistry_js_1 = require("../lib/servers/handlers/registry/CompositeHandlersRegistry.js");
+const index_js_1 = require("../lib/servers/handlers/groups/index.js");
+const LocalModeFactory_js_1 = require("../lib/servers/v2/factory/LocalModeFactory.js");
+const auth_stores_1 = require("@mcp-abap-adt/auth-stores");
+const auth_providers_1 = require("@mcp-abap-adt/auth-providers");
+const logger_1 = require("@mcp-abap-adt/logger");
+const StdioLogger_js_1 = require("../lib/servers/v2/utils/StdioLogger.js");
+const help_js_1 = require("./help.js");
+const http_1 = __importDefault(require("http"));
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {};
+    for (const arg of args) {
+        if (arg === '--help' || arg === '-h') {
+            result.help = true;
+        }
+        else if (arg === '--version' || arg === '-v') {
+            result.version = true;
+        }
+        else if (arg.startsWith('--mcp=')) {
+            result.mcp = arg.split('=')[1];
+        }
+        else if (arg.startsWith('--transport=')) {
+            const transport = arg.split('=')[1];
+            if (transport === 'stdio' || transport === 'sse' || transport === 'http') {
+                result.transport = transport;
+            }
+        }
+        else if (arg.startsWith('--http-port=')) {
+            result.httpPort = parseInt(arg.split('=')[1], 10);
+        }
+        else if (arg.startsWith('--sse-port=')) {
+            result.ssePort = parseInt(arg.split('=')[1], 10);
+        }
+        else if (arg.startsWith('--http-host=')) {
+            result.httpHost = arg.split('=')[1];
+        }
+        else if (arg.startsWith('--sse-host=')) {
+            result.sseHost = arg.split('=')[1];
+        }
+    }
+    // Defaults from environment variables
+    if (!result.transport) {
+        result.transport = process.env.MCP_TRANSPORT || 'stdio';
+    }
+    if (!result.httpPort) {
+        result.httpPort = parseInt(process.env.MCP_HTTP_PORT || '3000', 10);
+    }
+    if (!result.ssePort) {
+        result.ssePort = parseInt(process.env.MCP_SSE_PORT || '3001', 10);
+    }
+    if (!result.httpHost) {
+        result.httpHost = process.env.MCP_HTTP_HOST || '127.0.0.1';
+    }
+    if (!result.sseHost) {
+        result.sseHost = process.env.MCP_SSE_HOST || '127.0.0.1';
+    }
+    return result;
+}
+async function main() {
+    const args = parseArgs();
+    if (args.help) {
+        (0, help_js_1.showHelp)();
+        process.exit(0);
+    }
+    if (args.version) {
+        (0, help_js_1.showVersion)();
+        process.exit(0);
+    }
+    if (!args.mcp) {
+        console.error('Error: --mcp=destination parameter is required');
+        console.error('Use --help for usage information');
+        process.exit(1);
+    }
+    // For stdio transport, use minimal logger that only writes errors to stderr
+    // MCP protocol requires only JSON-RPC messages on stdout
+    const logger = args.transport === 'stdio'
+        ? new StdioLogger_js_1.StdioLogger()
+        : new logger_1.DefaultLogger();
+    try {
+        if (args.transport !== 'stdio') {
+            logger.info('Starting MCP Server v2...', {
+                destination: args.mcp,
+                transport: args.transport
+            });
+        }
+        // 1. Create stores and providers
+        const serviceKeyStore = new auth_stores_1.AbapServiceKeyStore(process.env.AUTH_BROKER_PATH?.split(process.platform === 'win32' ? ';' : ':')[0] || './service-keys', logger);
+        const sessionStore = new auth_stores_1.AbapSessionStore(process.env.AUTH_BROKER_PATH?.split(process.platform === 'win32' ? ';' : ':')[1] || './sessions', logger);
+        const tokenProvider = new auth_providers_1.BtpTokenProvider();
+        // 2. Create LocalModeFactory
+        const localModeFactory = new LocalModeFactory_js_1.LocalModeFactory({
+            serviceKeyStore,
+            sessionStore,
+            tokenProvider,
+            logger,
+        });
+        // 3. Create connection provider
+        const connectionProvider = localModeFactory.createConnectionProvider();
+        // 4. Create session manager
+        const sessionManager = new SessionManager_js_1.SessionManager();
+        // 5. Create protocol handler
+        const protocolHandler = new ProtocolHandler_js_1.ProtocolHandler();
+        // 6. Create handlers registry
+        const handlersRegistry = new CompositeHandlersRegistry_js_1.CompositeHandlersRegistry([
+            new index_js_1.ReadOnlyHandlersGroup(),
+            new index_js_1.HighLevelHandlersGroup(),
+            new index_js_1.LowLevelHandlersGroup(),
+            new index_js_1.SystemHandlersGroup(),
+            new index_js_1.SearchHandlersGroup(),
+        ]);
+        // 7. Create SDK MCP server
+        const sdkServer = new mcp_js_1.McpServer({
+            name: 'mcp-abap-adt-v2',
+            version: '2.0.0',
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        // 8. Create transport based on type
+        let transport;
+        let httpServer;
+        if (args.transport === 'sse') {
+            httpServer = http_1.default.createServer();
+            transport = new SseTransport_js_1.SseTransport({
+                port: args.ssePort,
+                host: args.sseHost,
+                endpoint: '/sse',
+            });
+            // SSE transport needs HTTP server integration
+            // This will be handled by the transport's start() method
+        }
+        else if (args.transport === 'http') {
+            httpServer = http_1.default.createServer();
+            transport = new StreamableHttpTransport_js_1.StreamableHttpTransport({
+                port: args.httpPort,
+                host: args.httpHost,
+            });
+            httpServer.on('request', async (req, res) => {
+                if ('handleRequest' in transport && typeof transport.handleRequest === 'function') {
+                    await transport.handleRequest(req, res);
+                }
+                else {
+                    res.statusCode = 501;
+                    res.end('Transport does not support HTTP requests');
+                }
+            });
+        }
+        else {
+            // stdio
+            transport = new StdioTransport_js_1.StdioTransport();
+        }
+        // 9. Create v2 server
+        const server = new McpServer_js_1.McpServer(transport, sessionManager, connectionProvider, protocolHandler, handlersRegistry, sdkServer, logger, args.mcp // Pass default destination from --mcp argument
+        );
+        // 10. Validate configuration
+        server.validateConfiguration();
+        // 11. Start HTTP server if needed
+        if (httpServer) {
+            const port = args.transport === 'sse' ? args.ssePort : args.httpPort;
+            const host = args.transport === 'sse' ? args.sseHost : args.httpHost;
+            httpServer.listen(port, host, () => {
+                if (args.transport !== 'stdio') {
+                    logger.info(`HTTP server listening on http://${host}:${port}`);
+                }
+            });
+        }
+        // 12. Start server
+        await server.start();
+        if (args.transport !== 'stdio') {
+            logger.info('MCP Server v2 started successfully');
+            const port = args.transport === 'sse' ? args.ssePort : args.httpPort;
+            logger.info(`Server is ready at http://${args.transport === 'sse' ? args.sseHost : args.httpHost}:${port}${args.transport === 'sse' ? '/sse' : ''}`);
+        }
+        // For stdio, don't log to stdout - MCP protocol requires only JSON-RPC messages
+        // Handle graceful shutdown
+        process.on('SIGINT', async () => {
+            if (args.transport !== 'stdio') {
+                logger.info('Received SIGINT, shutting down gracefully...');
+            }
+            if (httpServer) {
+                httpServer.close();
+            }
+            await server.stop();
+            process.exit(0);
+        });
+        process.on('SIGTERM', async () => {
+            if (args.transport !== 'stdio') {
+                logger.info('Received SIGTERM, shutting down gracefully...');
+            }
+            if (httpServer) {
+                httpServer.close();
+            }
+            await server.stop();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        // For stdio, write errors to stderr, not stdout
+        let errorMessage;
+        if (error instanceof Error) {
+            errorMessage = error.message;
+            if (error.stack) {
+                errorMessage += `\n${error.stack}`;
+            }
+        }
+        else if (error) {
+            try {
+                errorMessage = JSON.stringify(error, null, 2);
+            }
+            catch {
+                errorMessage = String(error);
+            }
+        }
+        else {
+            errorMessage = 'Unknown error';
+        }
+        if (args.transport === 'stdio') {
+            process.stderr.write(`[ERROR] 💥 Failed to start server: ${errorMessage}\n`);
+        }
+        else {
+            logger.error('Failed to start server:', error);
+        }
+        process.exit(1);
+    }
+}
+main();

package/dist/handlers/behavior_definition/high/handleCreateBehaviorDefinition.d.ts

@@ -0,0 +1,51 @@
+/**
+ * CreateBehaviorDefinition Handler - ABAP Behavior Definition Creation via ADT API
+ */
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateBehaviorDefinition";
+    readonly description: "Create a new ABAP Behavior Definition (BDEF) in SAP system.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly name: {
+                readonly type: "string";
+                readonly description: "Behavior Definition name (usually same as Root Entity name)";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Description";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number";
+            };
+            readonly root_entity: {
+                readonly type: "string";
+                readonly description: "Root Entity name (CDS View name)";
+            };
+            readonly implementation_type: {
+                readonly type: "string";
+                readonly description: "Implementation type: 'Managed', 'Unmanaged', 'Abstract', 'Projection'";
+                readonly enum: readonly ["Managed", "Unmanaged", "Abstract", "Projection"];
+            };
+            readonly activate: {
+                readonly type: "boolean";
+                readonly description: "Activate after creation. Default: true";
+            };
+        };
+        readonly required: readonly ["name", "package_name", "root_entity", "implementation_type"];
+    };
+};
+export declare function handleCreateBehaviorDefinition(context: HandlerContext, params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateBehaviorDefinition.d.ts.map

package/dist/handlers/behavior_definition/high/handleCreateBehaviorDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateBehaviorDefinition.d.ts","sourceRoot":"","sources":["../../../../src/handlers/behavior_definition/high/handleCreateBehaviorDefinition.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwClB,CAAC;AAYX,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,GAAG;;;;;;GA8GZ"}