@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/table/readonly/handleGetTable.js

@@ -0,0 +1,140 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetTable = handleGetTable;
+const utils_1 = require("../../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const writeResultToFile_1 = require("../../../lib/writeResultToFile");
+const z = __importStar(require("zod"));
+exports.TOOL_DEFINITION = {
+    name: "GetTable",
+    description: "[read-only] Retrieve ABAP table structure.",
+    inputSchema: {
+        table_name: z.string().describe("Name of the ABAP table")
+    }
+};
+function parseTableXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    const result = parser.parse(xml);
+    // DDIC Table (TABL/DT)
+    if (result['ddic:table']) {
+        const t = result['ddic:table'];
+        const fields = Array.isArray(t['ddic:fields']?.['ddic:field'])
+            ? t['ddic:fields']['ddic:field']
+            : t['ddic:fields']?.['ddic:field']
+                ? [t['ddic:fields']['ddic:field']]
+                : [];
+        return {
+            name: t['adtcore:name'],
+            objectType: 'table',
+            description: t['adtcore:description'],
+            package: t['adtcore:packageRef']?.['adtcore:name'] || null,
+            fields: fields.map(f => ({
+                name: f['ddic:name'],
+                dataType: f['ddic:dataType'],
+                length: parseInt(f['ddic:length'], 10),
+                decimals: parseInt(f['ddic:decimals'] || '0', 10),
+                key: f['ddic:keyFlag'] === 'true',
+                description: f['ddic:description']
+            }))
+        };
+    }
+    // fallback: return raw
+    return { raw: result };
+}
+async function handleGetTable(args) {
+    try {
+        if (!args?.table_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Table name is required');
+        }
+        const connection = (0, utils_1.getManagedConnection)();
+        const client = new adt_clients_1.CrudClient(connection);
+        await client.readTable(args.table_name);
+        const response = client.getReadResult();
+        if (!response) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Failed to read table');
+        }
+        // Parse XML responses; fall back to returning the payload as-is
+        if (typeof response.data === 'string' && response.data.trim().startsWith('<?xml')) {
+            const resultObj = parseTableXml(response.data);
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(resultObj, null, 2)
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(JSON.stringify(result, null, 2), args.filePath);
+            }
+            return result;
+        }
+        else {
+            const plainResult = {
+                isError: false,
+                content: [
+                    {
+                        type: "text",
+                        text: response.data
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(response.data, args.filePath);
+            }
+            return plainResult;
+        }
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: error instanceof Error ? error.message : String(error)
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/transport/handleCreateTransport.d.ts

@@ -0,0 +1,50 @@
+/**
+ * CreateTransport Handler - Create new ABAP transport request via ADT API
+ *
+ * Uses TransportBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: create
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateTransport";
+    readonly description: "Create a new ABAP transport request in SAP system for development objects.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly transport_type: {
+                readonly type: "string";
+                readonly description: "Transport type: 'workbench' (cross-client) or 'customizing' (client-specific)";
+                readonly enum: readonly ["workbench", "customizing"];
+                readonly default: "workbench";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Transport request description (mandatory)";
+            };
+            readonly target_system: {
+                readonly type: "string";
+                readonly description: "Target system for transport (optional, e.g., 'PRD', 'QAS'). If not provided or empty, uses 'LOCAL'";
+            };
+            readonly owner: {
+                readonly type: "string";
+                readonly description: "Transport owner (optional, defaults to current user)";
+            };
+        };
+        readonly required: readonly ["description"];
+    };
+};
+/**
+ * Main handler for CreateTransport MCP tool
+ *
+ * Uses TransportBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleCreateTransport(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateTransport.d.ts.map

package/dist/handlers/transport/handleCreateTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateTransport.d.ts","sourceRoot":"","sources":["../../../src/handlers/transport/handleCreateTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,CAAC;AAUX;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,GAAG;;;;;;GAqHpD"}

package/dist/handlers/transport/handleCreateTransport.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * CreateTransport Handler - Create new ABAP transport request via ADT API
+ *
+ * Uses TransportBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: create
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleCreateTransport = handleCreateTransport;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const adt_clients_1 = require("@mcp-abap-adt/adt-clients");
+exports.TOOL_DEFINITION = {
+    name: "CreateTransport",
+    description: "Create a new ABAP transport request in SAP system for development objects.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            transport_type: {
+                type: "string",
+                description: "Transport type: 'workbench' (cross-client) or 'customizing' (client-specific)",
+                enum: ["workbench", "customizing"],
+                default: "workbench"
+            },
+            description: {
+                type: "string",
+                description: "Transport request description (mandatory)"
+            },
+            target_system: {
+                type: "string",
+                description: "Target system for transport (optional, e.g., 'PRD', 'QAS'). If not provided or empty, uses 'LOCAL'"
+            },
+            owner: {
+                type: "string",
+                description: "Transport owner (optional, defaults to current user)"
+            }
+        },
+        required: ["description"]
+    }
+};
+/**
+ * Main handler for CreateTransport MCP tool
+ *
+ * Uses TransportBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+async function handleCreateTransport(args) {
+    try {
+        // Validate required parameters
+        if (!args?.description) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Transport description is required');
+        }
+        const typedArgs = args;
+        const connection = (0, utils_2.getManagedConnection)();
+        utils_2.logger.info(`Starting transport creation: ${typedArgs.description}`);
+        try {
+            // Create client
+            const client = new adt_clients_1.CrudClient(connection);
+            // Create transport
+            await client.createTransport(typedArgs.description, typedArgs.transport_type === 'customizing' ? 'customizing' : 'workbench');
+            // Get create result
+            const createResult = client.getCreateResult();
+            utils_2.logger.info(`✅ CreateTransport completed successfully`);
+            // Parse response data if available
+            let transportInfo = {};
+            let transportNumber;
+            let taskNumber;
+            if (createResult?.data) {
+                if (typeof createResult.data === 'string') {
+                    // If data is XML string, try to parse it
+                    try {
+                        const { XMLParser } = require('fast-xml-parser');
+                        const parser = new XMLParser({
+                            ignoreAttributes: false,
+                            attributeNamePrefix: '',
+                            parseAttributeValue: true,
+                        });
+                        const result = parser.parse(createResult.data);
+                        const root = result['tm:root'] || result['root'];
+                        const request = root?.['tm:request'] || {};
+                        const task = request?.['tm:task'] || {};
+                        transportInfo = {
+                            transport_number: request['tm:number'] || transportNumber,
+                            description: request['tm:desc'] || request['tm:description'] || typedArgs.description,
+                            type: request['tm:type'],
+                            target_system: request['tm:target'],
+                            target_desc: request['tm:target_desc'],
+                            cts_project: request['tm:cts_project'],
+                            uri: request['tm:uri'],
+                            owner: task['tm:owner'] || request['tm:owner'] || typedArgs.owner
+                        };
+                    }
+                    catch (parseError) {
+                        // If parsing fails, use basic info
+                        transportInfo = {
+                            transport_number: transportNumber,
+                            description: typedArgs.description,
+                            type: typedArgs.transport_type === 'customizing' ? 'T' : 'K',
+                            owner: typedArgs.owner
+                        };
+                    }
+                }
+                else if (typeof createResult.data === 'object') {
+                    transportInfo = createResult.data;
+                }
+            }
+            // Use builder state if response parsing didn't provide transport number
+            if (!transportInfo.transport_number && transportNumber) {
+                transportInfo.transport_number = transportNumber;
+            }
+            if (!transportInfo.task_number && taskNumber) {
+                transportInfo.task_number = taskNumber;
+            }
+            return (0, utils_2.return_response)({
+                data: JSON.stringify({
+                    success: true,
+                    transport_request: transportInfo.transport_number || transportNumber,
+                    task_number: transportInfo.task_number || taskNumber,
+                    description: transportInfo.description || typedArgs.description,
+                    type: transportInfo.type || (typedArgs.transport_type === 'customizing' ? 'T' : 'K'),
+                    target_system: transportInfo.target_system || typedArgs.target_system || 'LOCAL',
+                    target_desc: transportInfo.target_desc,
+                    cts_project: transportInfo.cts_project,
+                    owner: transportInfo.owner || typedArgs.owner,
+                    uri: transportInfo.uri,
+                    message: `Transport request ${transportInfo.transport_number || transportNumber || 'unknown'} created successfully`
+                }, null, 2),
+                status: createResult?.status || 200,
+                statusText: createResult?.statusText || 'OK',
+                headers: createResult?.headers || {},
+                config: createResult?.config || {}
+            });
+        }
+        catch (error) {
+            utils_2.logger.error(`Error creating transport:`, error);
+            const errorMessage = error.response?.data
+                ? (typeof error.response.data === 'string' ? error.response.data : JSON.stringify(error.response.data))
+                : error.message || String(error);
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to create transport: ${errorMessage}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/transport/handleGetTransport.d.ts

@@ -0,0 +1,44 @@
+/**
+ * GetTransport Handler - Retrieve ABAP transport request information via ADT API
+ *
+ * Retrieves transport request details including:
+ * - Transport metadata (number, description, type, status)
+ * - Owner and target system information
+ * - Included objects and tasks
+ * - Change history
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetTransport";
+    readonly description: "Retrieve ABAP transport request information including metadata, included objects, and status from SAP system.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly transport_number: {
+                readonly type: "string";
+                readonly description: "Transport request number (e.g., E19K905635, DEVK905123)";
+            };
+            readonly include_objects: {
+                readonly type: "boolean";
+                readonly description: "Include list of objects in transport (default: true)";
+                readonly default: true;
+            };
+            readonly include_tasks: {
+                readonly type: "boolean";
+                readonly description: "Include list of tasks in transport (default: true)";
+                readonly default: true;
+            };
+        };
+        readonly required: readonly ["transport_number"];
+    };
+};
+/**
+ * Main handler for GetTransport MCP tool
+ */
+export declare function handleGetTransport(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleGetTransport.d.ts.map

package/dist/handlers/transport/handleGetTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetTransport.d.ts","sourceRoot":"","sources":["../../../src/handlers/transport/handleGetTransport.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;CAuBlB,CAAC;AAyGX;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;GA0DjD"}

package/dist/handlers/transport/handleGetTransport.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * GetTransport Handler - Retrieve ABAP transport request information via ADT API
+ *
+ * Retrieves transport request details including:
+ * - Transport metadata (number, description, type, status)
+ * - Owner and target system information
+ * - Included objects and tasks
+ * - Change history
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetTransport = handleGetTransport;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const fast_xml_parser_1 = require("fast-xml-parser");
+exports.TOOL_DEFINITION = {
+    name: "GetTransport",
+    description: "Retrieve ABAP transport request information including metadata, included objects, and status from SAP system.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            transport_number: {
+                type: "string",
+                description: "Transport request number (e.g., E19K905635, DEVK905123)"
+            },
+            include_objects: {
+                type: "boolean",
+                description: "Include list of objects in transport (default: true)",
+                default: true
+            },
+            include_tasks: {
+                type: "boolean",
+                description: "Include list of tasks in transport (default: true)",
+                default: true
+            }
+        },
+        required: ["transport_number"]
+    }
+};
+/**
+ * Parse transport request XML response
+ */
+function parseTransportXml(xmlData, includeObjects = true, includeTasks = true) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        textNodeName: '_text',
+        parseAttributeValue: true,
+        isArray: (name, jpath, isLeafNode, isAttribute) => {
+            // Arrays for multiple objects/tasks
+            return ['tm:object', 'tm:task', 'object', 'task'].includes(name);
+        }
+    });
+    const result = parser.parse(xmlData);
+    const root = result['tm:root'] || result['root'];
+    if (!root) {
+        throw new utils_1.McpError(utils_1.ErrorCode.InternalError, 'Invalid transport XML structure - no tm:root found');
+    }
+    // Get detailed transport info from tm:request inside tm:root
+    const request = root['tm:request'] || {};
+    // Extract basic transport information from both root attributes and request details
+    const transportInfo = {
+        number: root['adtcore:name'] || request['tm:number'] || root['name'],
+        description: request['tm:desc'] || request['description'] || root['tm:description'],
+        type: request['tm:type'] || root['tm:object_type'] || root['type'],
+        status: request['tm:status'] || root['tm:status'],
+        status_text: request['tm:status_text'],
+        owner: request['tm:owner'] || root['tm:owner'],
+        target_system: request['tm:target'] || root['tm:target'],
+        target_desc: request['tm:target_desc'],
+        created_at: root['adtcore:createdAt'] || request['tm:createdAt'] || root['createdAt'],
+        created_by: root['adtcore:createdBy'] || request['tm:createdBy'] || root['createdBy'],
+        changed_at: root['adtcore:changedAt'] || request['tm:changedAt'] || root['changedAt'],
+        changed_by: root['adtcore:changedBy'] || request['tm:changedBy'] || root['changedBy'],
+        release_date: request['tm:releaseDate'] || root['releaseDate'],
+        client: request['tm:source_client'] || root['tm:client'],
+        cts_project: request['tm:cts_project'],
+        cts_project_desc: request['tm:cts_project_desc']
+    };
+    // Extract objects if requested
+    let objects = [];
+    if (includeObjects && request['tm:all_objects']) {
+        const objectList = request['tm:all_objects']['tm:abap_object'] || [];
+        objects = Array.isArray(objectList) ? objectList : [objectList];
+        objects = objects.map(obj => ({
+            name: obj['tm:name'],
+            type: obj['tm:type'],
+            wbtype: obj['tm:wbtype'],
+            pgmid: obj['tm:pgmid'],
+            description: obj['tm:obj_desc'],
+            position: obj['tm:position'],
+            lock_status: obj['tm:lock_status'],
+            info: obj['tm:obj_info']
+        }));
+    }
+    // Extract tasks if requested
+    let tasks = [];
+    if (includeTasks && request['tm:task']) {
+        const taskList = Array.isArray(request['tm:task']) ? request['tm:task'] : [request['tm:task']];
+        tasks = taskList.map(task => ({
+            number: task['tm:number'],
+            parent: task['tm:parent'],
+            description: task['tm:desc'],
+            type: task['tm:type'],
+            status: task['tm:status'],
+            status_text: task['tm:status_text'],
+            owner: task['tm:owner'],
+            target: task['tm:target'],
+            target_desc: task['tm:target_desc'],
+            client: task['tm:source_client'],
+            created_at: task['tm:lastchanged_timestamp'],
+            objects: task['tm:abap_object'] ? (Array.isArray(task['tm:abap_object']) ? task['tm:abap_object'] : [task['tm:abap_object']]).map(obj => ({
+                name: obj['tm:name'],
+                type: obj['tm:type'],
+                wbtype: obj['tm:wbtype'],
+                description: obj['tm:obj_desc'],
+                position: obj['tm:position']
+            })) : []
+        }));
+    }
+    return {
+        transport: transportInfo,
+        objects: includeObjects ? objects : undefined,
+        tasks: includeTasks ? tasks : undefined,
+        object_count: objects.length,
+        task_count: tasks.length
+    };
+}
+/**
+ * Main handler for GetTransport MCP tool
+ */
+async function handleGetTransport(args) {
+    try {
+        // Validate required parameters
+        if (!args?.transport_number) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Transport number is required');
+        }
+        const typedArgs = args;
+        const includeObjects = typedArgs.include_objects !== false;
+        const includeTasks = typedArgs.include_tasks !== false;
+        console.log(`[DEBUG] GetTransport: ${typedArgs.transport_number}`);
+        console.log(`[DEBUG] Include objects: ${includeObjects}, Include tasks: ${includeTasks}`);
+        const baseUrl = await (0, utils_2.getBaseUrl)();
+        let url = `${baseUrl}/sap/bc/adt/cts/transportrequests/${typedArgs.transport_number}`;
+        // Add query parameters for additional information
+        const params = [];
+        if (includeObjects)
+            params.push('includeObjects=true');
+        if (includeTasks)
+            params.push('includeTasks=true');
+        if (params.length > 0) {
+            url += `?${params.join('&')}`;
+        }
+        const headers = {
+            'Accept': 'application/vnd.sap.adt.transportorganizer.v1+xml'
+        };
+        console.log(`[DEBUG] GET from: ${url}`);
+        // Get transport request
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default', null, undefined, headers);
+        console.log('[DEBUG] GetTransport response status:', response.status);
+        // Parse XML response
+        const transportData = parseTransportXml(response.data, includeObjects, includeTasks);
+        return (0, utils_2.return_response)({
+            data: JSON.stringify({
+                success: true,
+                transport_number: typedArgs.transport_number,
+                ...transportData,
+                message: `Transport ${typedArgs.transport_number} retrieved successfully`
+            }, null, 2),
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+            config: response.config
+        });
+    }
+    catch (error) {
+        if (error instanceof utils_1.McpError) {
+            throw error;
+        }
+        return (0, utils_2.return_error)(error);
+    }
+}

package/dist/handlers/view/handleCreateView.d.ts

@@ -0,0 +1,52 @@
+/**
+ * CreateView Handler - CDS/Classic View Creation via ADT API
+ *
+ * Uses ViewBuilder from @mcp-abap-adt/adt-clients for all operations.
+ * Session and lock management handled internally by builder.
+ *
+ * Workflow: validate -> create -> lock -> update -> check -> unlock -> (activate)
+ */
+export declare const TOOL_DEFINITION: {
+    readonly name: "CreateView";
+    readonly description: "Create CDS View or Classic View in SAP using DDL syntax. Both types use the same API workflow, differing only in DDL content (CDS has @AbapCatalog annotations).";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly view_name: {
+                readonly type: "string";
+                readonly description: "View name (e.g., ZOK_R_TEST_0002, Z_I_MY_VIEW). Must follow SAP naming conventions.";
+            };
+            readonly ddl_source: {
+                readonly type: "string";
+                readonly description: "Complete DDL source code. CDS: include @AbapCatalog.sqlViewName and other annotations. Classic: plain 'define view' statement.";
+            };
+            readonly package_name: {
+                readonly type: "string";
+                readonly description: "Package name (e.g., ZOK_LAB, $TMP for local objects)";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+                readonly description: "Transport request number (e.g., E19K905635). Required for transportable packages.";
+            };
+            readonly description: {
+                readonly type: "string";
+                readonly description: "Optional description. If not provided, view_name will be used.";
+            };
+        };
+        readonly required: readonly ["view_name", "ddl_source", "package_name"];
+    };
+};
+/**
+ * Main handler for CreateView MCP tool
+ *
+ * Uses ViewBuilder from @mcp-abap-adt/adt-clients for all operations
+ * Session and lock management handled internally by builder
+ */
+export declare function handleCreateView(params: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleCreateView.d.ts.map

package/dist/handlers/view/handleCreateView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCreateView.d.ts","sourceRoot":"","sources":["../../../src/handlers/view/handleCreateView.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAQH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BlB,CAAC;AAWX;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,GAAG;;;;;;GA0GjD"}