@mcp-abap-adt/core 2.5.1 → 2.5.2

package/dist/handlers/system/handleGetSqlQuery.d.ts

@@ -0,0 +1,49 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetSqlQuery";
+    readonly description: "Execute freestyle SQL queries via SAP ADT Data Preview API.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly sql_query: {
+                readonly type: "string";
+                readonly description: "SQL query to execute";
+            };
+            readonly row_number: {
+                readonly type: "number";
+                readonly description: "Maximum number of rows to return";
+                readonly default: 100;
+            };
+        };
+        readonly required: readonly ["sql_query"];
+    };
+};
+/**
+ * Interface for SQL query execution response
+ */
+export interface SqlQueryResponse {
+    sql_query: string;
+    row_number: number;
+    execution_time?: number;
+    total_rows?: number;
+    columns: Array<{
+        name: string;
+        type: string;
+        description?: string;
+        length?: number;
+    }>;
+    rows: Array<Record<string, any>>;
+}
+/**
+ * Handler to execute freestyle SQL queries via SAP ADT Data Preview API
+ *
+ * @param args - Tool arguments containing sql_query and optional row_number parameter
+ * @returns Response with parsed SQL query results or error
+ */
+export declare function handleGetSqlQuery(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetSqlQuery.d.ts.map

package/dist/handlers/system/handleGetSqlQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetSqlQuery.d.ts","sourceRoot":"","sources":["../../../src/handlers/system/handleGetSqlQuery.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;CAoBlB,CAAC;AAEX;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;IACH,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;CACpC;AAsGD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,GAAG;;;;;;GA+DhD"}

package/dist/handlers/system/handleGetSqlQuery.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetSqlQuery = handleGetSqlQuery;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const writeResultToFile_1 = require("../../lib/writeResultToFile");
+exports.TOOL_DEFINITION = {
+    "name": "GetSqlQuery",
+    "description": "Execute freestyle SQL queries via SAP ADT Data Preview API.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "sql_query": {
+                "type": "string",
+                "description": "SQL query to execute"
+            },
+            "row_number": {
+                "type": "number",
+                "description": "Maximum number of rows to return",
+                "default": 100
+            }
+        },
+        "required": [
+            "sql_query"
+        ]
+    }
+};
+/**
+ * Parse SAP ADT XML response from freestyle SQL query and convert to JSON format
+ * @param xmlData - Raw XML response from ADT
+ * @param sqlQuery - Original SQL query
+ * @param rowNumber - Number of rows requested
+ * @returns Parsed SQL query response
+ */
+function parseSqlQueryXml(xmlData, sqlQuery, rowNumber) {
+    try {
+        // Extract basic information
+        const totalRowsMatch = xmlData.match(/<dataPreview:totalRows>(\d+)<\/dataPreview:totalRows>/);
+        const totalRows = totalRowsMatch ? parseInt(totalRowsMatch[1]) : 0;
+        const queryTimeMatch = xmlData.match(/<dataPreview:queryExecutionTime>([\d.]+)<\/dataPreview:queryExecutionTime>/);
+        const queryExecutionTime = queryTimeMatch ? parseFloat(queryTimeMatch[1]) : 0;
+        // Extract column metadata
+        const columns = [];
+        const columnMatches = xmlData.match(/<dataPreview:metadata[^>]*>/g);
+        if (columnMatches) {
+            columnMatches.forEach(match => {
+                const nameMatch = match.match(/dataPreview:name="([^"]+)"/);
+                const typeMatch = match.match(/dataPreview:type="([^"]+)"/);
+                const descMatch = match.match(/dataPreview:description="([^"]+)"/);
+                const lengthMatch = match.match(/dataPreview:length="(\d+)"/);
+                if (nameMatch) {
+                    columns.push({
+                        name: nameMatch[1],
+                        type: typeMatch ? typeMatch[1] : 'UNKNOWN',
+                        description: descMatch ? descMatch[1] : '',
+                        length: lengthMatch ? parseInt(lengthMatch[1]) : undefined
+                    });
+                }
+            });
+        }
+        // Extract row data
+        const rows = [];
+        // Find all column sections
+        const columnSections = xmlData.match(/<dataPreview:columns>.*?<\/dataPreview:columns>/gs);
+        if (columnSections && columnSections.length > 0) {
+            // Extract data for each column
+            const columnData = {};
+            columnSections.forEach((section, index) => {
+                if (index < columns.length) {
+                    const columnName = columns[index].name;
+                    const dataMatches = section.match(/<dataPreview:data[^>]*>(.*?)<\/dataPreview:data>/g);
+                    if (dataMatches) {
+                        columnData[columnName] = dataMatches.map(match => {
+                            const content = match.replace(/<[^>]+>/g, '');
+                            return content || null;
+                        });
+                    }
+                    else {
+                        columnData[columnName] = [];
+                    }
+                }
+            });
+            // Convert column-based data to row-based data
+            const maxRowCount = Math.max(...Object.values(columnData).map(arr => arr.length), 0);
+            for (let rowIndex = 0; rowIndex < maxRowCount; rowIndex++) {
+                const row = {};
+                columns.forEach(column => {
+                    const columnValues = columnData[column.name] || [];
+                    row[column.name] = columnValues[rowIndex] || null;
+                });
+                rows.push(row);
+            }
+        }
+        return {
+            sql_query: sqlQuery,
+            row_number: rowNumber,
+            execution_time: queryExecutionTime,
+            total_rows: totalRows,
+            columns,
+            rows
+        };
+    }
+    catch (parseError) {
+        utils_2.logger.error('Failed to parse SQL query XML:', parseError);
+        // Return basic structure on parse error
+        return {
+            sql_query: sqlQuery,
+            row_number: rowNumber,
+            columns: [],
+            rows: [],
+            error: 'Failed to parse XML response'
+        };
+    }
+}
+/**
+ * Handler to execute freestyle SQL queries via SAP ADT Data Preview API
+ *
+ * @param args - Tool arguments containing sql_query and optional row_number parameter
+ * @returns Response with parsed SQL query results or error
+ */
+async function handleGetSqlQuery(args) {
+    try {
+        utils_2.logger.info('handleGetSqlQuery called with args:', args);
+        if (!args?.sql_query) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'SQL query is required');
+        }
+        const sqlQuery = args.sql_query;
+        const rowNumber = args.row_number || 100; // Default to 100 rows if not specified
+        utils_2.logger.info('Executing SQL query', { sqlQuery, rowNumber });
+        // Build URL for freestyle data preview with rowNumber parameter
+        const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/datapreview/freestyle?rowNumber=${rowNumber}`;
+        utils_2.logger.info(`Making SQL query request to: ${url}`);
+        // Execute POST request with SQL query in body
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'POST', 'long', sqlQuery);
+        if (response.status === 200 && response.data) {
+            utils_2.logger.info('SQL query request completed successfully', { status: response.status });
+            // Parse the XML response
+            const parsedData = parseSqlQueryXml(response.data, sqlQuery, rowNumber);
+            utils_2.logger.info('Parsed SQL query data', {
+                totalRows: parsedData.total_rows,
+                columnsCount: parsedData.columns.length,
+                rowsCount: parsedData.rows.length,
+                executionTime: parsedData.execution_time
+            });
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(parsedData, null, 2)
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(result, args.filePath);
+            }
+            return result;
+        }
+        else {
+            throw new utils_1.McpError(utils_1.ErrorCode.InternalError, `Failed to execute SQL query. Status: ${response.status}`);
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/system/handleGetTransaction.d.ts

@@ -0,0 +1,42 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetTransaction";
+    readonly description: "Retrieve ABAP transaction details.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly transaction_name: {
+                readonly type: "string";
+                readonly description: "Name of the ABAP transaction";
+            };
+        };
+        readonly required: readonly ["transaction_name"];
+    };
+};
+export declare function handleGetTransaction(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        json: {
+            name: any;
+            objectType: string;
+            description: any;
+            package: any;
+            type: any;
+            raw?: undefined;
+        } | {
+            raw: any;
+            name?: undefined;
+            objectType?: undefined;
+            description?: undefined;
+            package?: undefined;
+            type?: undefined;
+        };
+    }[];
+}>;
+//# sourceMappingURL=handleGetTransaction.d.ts.map

package/dist/handlers/system/handleGetTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetTransaction.d.ts","sourceRoot":"","sources":["../../../src/handlers/system/handleGetTransaction.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAelB,CAAC;AA2BX,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CnD"}

package/dist/handlers/system/handleGetTransaction.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetTransaction = handleGetTransaction;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const writeResultToFile_1 = require("../../lib/writeResultToFile");
+exports.TOOL_DEFINITION = {
+    "name": "GetTransaction",
+    "description": "Retrieve ABAP transaction details.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "transaction_name": {
+                "type": "string",
+                "description": "Name of the ABAP transaction"
+            }
+        },
+        "required": [
+            "transaction_name"
+        ]
+    }
+};
+function parseTransactionXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    const result = parser.parse(xml);
+    // ADT Transaction XML (opr:objectProperties)
+    if (result['opr:objectProperties'] && result['opr:objectProperties']['opr:object']) {
+        const obj = result['opr:objectProperties']['opr:object'];
+        return {
+            name: obj['name'],
+            objectType: 'transaction',
+            description: obj['text'],
+            package: obj['package'],
+            type: obj['type']
+        };
+    }
+    // fallback: return raw
+    return { raw: result };
+}
+async function handleGetTransaction(args) {
+    try {
+        if (!args?.transaction_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Transaction name is required');
+        }
+        const encodedTransactionName = (0, utils_2.encodeSapObjectName)(args.transaction_name);
+        const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/repository/informationsystem/objectproperties/values?uri=%2Fsap%2Fbc%2Fadt%2Fvit%2Fwb%2Fobject_type%2Ftrant%2Fobject_name%2F${encodedTransactionName}&facet=package&facet=appl`;
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
+        // Parse XML responses; otherwise return the payload unchanged
+        if (typeof response.data === 'string' && response.data.trim().startsWith('<?xml')) {
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "json",
+                        json: parseTransactionXml(response.data)
+                    }
+                ]
+            };
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(result, args.filePath);
+            }
+            return result;
+        }
+        else {
+            const plainResult = (0, utils_2.return_response)(response);
+            if (args.filePath) {
+                (0, writeResultToFile_1.writeResultToFile)(plainResult, args.filePath);
+            }
+            return plainResult;
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+}

package/dist/handlers/system/handleGetTypeInfo.d.ts

@@ -0,0 +1,69 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetTypeInfo";
+    readonly description: "Retrieve ABAP type information.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly type_name: {
+                readonly type: "string";
+                readonly description: "Name of the ABAP type";
+            };
+        };
+        readonly required: readonly ["type_name"];
+    };
+};
+export declare function handleGetTypeInfo(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        json: {
+            name: any;
+            objectType: string;
+            description: any;
+            dataType: any;
+            length: number;
+            decimals: number;
+            domain: any;
+            package: any;
+            labels: {
+                short: any;
+                medium: any;
+                long: any;
+                heading: any;
+            };
+            type?: undefined;
+            raw?: undefined;
+        } | {
+            name: any;
+            objectType: string;
+            description: any;
+            package: any;
+            type: any;
+            dataType?: undefined;
+            length?: undefined;
+            decimals?: undefined;
+            domain?: undefined;
+            labels?: undefined;
+            raw?: undefined;
+        } | {
+            raw: any;
+            name?: undefined;
+            objectType?: undefined;
+            description?: undefined;
+            dataType?: undefined;
+            length?: undefined;
+            decimals?: undefined;
+            domain?: undefined;
+            package?: undefined;
+            labels?: undefined;
+            type?: undefined;
+        };
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetTypeInfo.d.ts.map

package/dist/handlers/system/handleGetTypeInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetTypeInfo.d.ts","sourceRoot":"","sources":["../../../src/handlers/system/handleGetTypeInfo.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAelB,CAAC;AAiDX,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiGhD"}

package/dist/handlers/system/handleGetTypeInfo.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleGetTypeInfo = handleGetTypeInfo;
+const utils_1 = require("../../lib/utils");
+const utils_2 = require("../../lib/utils");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const getObjectsListCache_1 = require("../../lib/getObjectsListCache");
+exports.TOOL_DEFINITION = {
+    "name": "GetTypeInfo",
+    "description": "Retrieve ABAP type information.",
+    "inputSchema": {
+        "type": "object",
+        "properties": {
+            "type_name": {
+                "type": "string",
+                "description": "Name of the ABAP type"
+            }
+        },
+        "required": [
+            "type_name"
+        ]
+    }
+};
+function parseTypeInfoXml(xml) {
+    const parser = new fast_xml_parser_1.XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: '',
+        parseAttributeValue: true,
+        trimValues: true
+    });
+    const result = parser.parse(xml);
+    // Data Element (DTEL/DE)
+    if (result['blue:wbobj'] && result['blue:wbobj']['dtel:dataElement']) {
+        const wb = result['blue:wbobj'];
+        const dtel = wb['dtel:dataElement'];
+        return {
+            name: wb['adtcore:name'],
+            objectType: 'data_element',
+            description: wb['adtcore:description'],
+            dataType: dtel['dtel:dataType'],
+            length: parseInt(dtel['dtel:dataTypeLength'], 10),
+            decimals: parseInt(dtel['dtel:dataTypeDecimals'], 10),
+            domain: dtel['dtel:typeName'],
+            package: wb['adtcore:packageRef']?.['adtcore:name'] || null,
+            labels: {
+                short: dtel['dtel:shortFieldLabel'],
+                medium: dtel['dtel:mediumFieldLabel'],
+                long: dtel['dtel:longFieldLabel'],
+                heading: dtel['dtel:headingFieldLabel']
+            }
+        };
+    }
+    // Domain (DOMA/DD) via repository informationsystem
+    if (result['opr:objectProperties'] && result['opr:objectProperties']['opr:object']) {
+        const obj = result['opr:objectProperties']['opr:object'];
+        return {
+            name: obj['name'],
+            objectType: 'domain',
+            description: obj['text'],
+            package: obj['package'],
+            type: obj['type'],
+        };
+    }
+    // Table Type (not implemented, fallback)
+    return { raw: result };
+}
+async function handleGetTypeInfo(args) {
+    try {
+        if (!args?.type_name) {
+            throw new utils_1.McpError(utils_1.ErrorCode.InvalidParams, 'Type name is required');
+        }
+    }
+    catch (error) {
+        // MCP-compliant error response: always return content[] with type "text"
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: `ADT error: ${String(error)}`
+                }
+            ]
+        };
+    }
+    try {
+        const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/ddic/domains/${(0, utils_2.encodeSapObjectName)(args.type_name)}/source/main`;
+        const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
+        const result = {
+            isError: false,
+            content: [
+                {
+                    type: "json",
+                    json: parseTypeInfoXml(response.data)
+                }
+            ]
+        };
+        getObjectsListCache_1.objectsListCache.setCache(result);
+        return result;
+    }
+    catch (error) {
+        // no domain found, try data element
+        try {
+            const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/ddic/dataelements/${(0, utils_2.encodeSapObjectName)(args.type_name)}`;
+            const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
+            const result = {
+                isError: false,
+                content: [
+                    {
+                        type: "json",
+                        json: parseTypeInfoXml(response.data)
+                    }
+                ]
+            };
+            getObjectsListCache_1.objectsListCache.setCache(result);
+            return result;
+        }
+        catch (error) {
+            // no data element found, try table type
+            try {
+                const url = `${await (0, utils_2.getBaseUrl)()}/sap/bc/adt/ddic/tabletypes/${(0, utils_2.encodeSapObjectName)(args.type_name)}`;
+                const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
+                const result = {
+                    isError: false,
+                    content: [
+                        {
+                            type: "json",
+                            json: parseTypeInfoXml(response.data)
+                        }
+                    ]
+                };
+                getObjectsListCache_1.objectsListCache.setCache(result);
+                return result;
+            }
+            catch (error) {
+                // fallback: try repository informationsystem for domain
+                try {
+                    const baseUrl = await (0, utils_2.getBaseUrl)();
+                    const uri = encodeURIComponent(`/sap/bc/adt/ddic/domains/${args.type_name.toLowerCase()}`);
+                    const url = `${baseUrl}/sap/bc/adt/repository/informationsystem/objectproperties/values?uri=${uri}`;
+                    const response = await (0, utils_2.makeAdtRequestWithTimeout)(url, 'GET', 'default');
+                    const result = {
+                        isError: false,
+                        content: [
+                            {
+                                type: "json",
+                                json: parseTypeInfoXml(response.data)
+                            }
+                        ]
+                    };
+                    getObjectsListCache_1.objectsListCache.setCache(result);
+                    return result;
+                }
+                catch (error) {
+                    // MCP-compliant error response: always return content[] with type "text"
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: "text",
+                                text: `ADT error: ${String(error)}`
+                            }
+                        ]
+                    };
+                }
+            }
+        }
+    }
+}

package/dist/handlers/system/handleGetWhereUsed.d.ts

@@ -0,0 +1,69 @@
+export declare const TOOL_DEFINITION: {
+    readonly name: "GetWhereUsed";
+    readonly description: "Retrieve where-used references for ABAP objects via ADT usageReferences.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Name of the ABAP object";
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly description: "Type of the ABAP object";
+            };
+            readonly detailed: {
+                readonly type: "boolean";
+                readonly description: "If true, returns all references including packages and internal components.";
+                readonly default: false;
+            };
+        };
+        readonly required: readonly ["object_name", "object_type"];
+    };
+};
+/**
+ * Returns where-used references for ABAP objects.
+ *
+ * Supported object_type values:
+ * - class
+ * - program
+ * - include
+ * - function (function group)
+ * - functionmodule (function module, format: GROUP|FM_NAME)
+ * - interface
+ * - badi, badi_class, badi-implementation
+ * - package
+ * - table, tabl, TABL
+ * - dataelement
+ * - domain
+ * - view, ddicview, cdsview
+ * - searchhelp
+ * - messageclass
+ * - transaction
+ * - bdef, BDEF
+ * - enhancementspot, enhs, enho
+ * - enhancementimpl, enhi
+ */
+export declare function handleGetWhereUsed(args: any): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        json: {
+            object_name: string;
+            object_type: string;
+            object_uri: string;
+            detailed: boolean;
+            total_references: number;
+            total_found: number;
+            filtered_out: number;
+            references: any;
+        };
+    }[];
+} | {
+    isError: boolean;
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;
+//# sourceMappingURL=handleGetWhereUsed.d.ts.map

package/dist/handlers/system/handleGetWhereUsed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleGetWhereUsed.d.ts","sourceRoot":"","sources":["../../../src/handlers/system/handleGetWhereUsed.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAC;AAuUX;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;GA0FjD"}