@mcp-abap-adt/core 2.5.2 → 2.7.0

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

@@ -1,49 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,176 +0,0 @@
-"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

@@ -1,42 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,91 +0,0 @@
-"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

@@ -1,69 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,169 +0,0 @@
-"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

@@ -1,69 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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"}