@mcp-abap-adt/core 2.4.2 → 2.5.0

package/dist/handlers/compact/high/handleHandlerProfileRun.d.ts

@@ -0,0 +1,92 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerProfileRun";
+    readonly description: "Compact runtime profiling run. Executes CLASS or PROGRAM with profiling enabled.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly target_type: {
+                readonly type: "string";
+                readonly enum: readonly ["CLASS", "PROGRAM"];
+                readonly description: "Profile execution target kind.";
+            };
+            readonly class_name: {
+                readonly type: "string";
+            };
+            readonly program_name: {
+                readonly type: "string";
+            };
+            readonly description: {
+                readonly type: "string";
+            };
+            readonly all_procedural_units: {
+                readonly type: "boolean";
+            };
+            readonly all_misc_abap_statements: {
+                readonly type: "boolean";
+            };
+            readonly all_internal_table_events: {
+                readonly type: "boolean";
+            };
+            readonly all_dynpro_events: {
+                readonly type: "boolean";
+            };
+            readonly aggregate: {
+                readonly type: "boolean";
+            };
+            readonly explicit_on_off: {
+                readonly type: "boolean";
+            };
+            readonly with_rfc_tracing: {
+                readonly type: "boolean";
+            };
+            readonly all_system_kernel_events: {
+                readonly type: "boolean";
+            };
+            readonly sql_trace: {
+                readonly type: "boolean";
+            };
+            readonly all_db_events: {
+                readonly type: "boolean";
+            };
+            readonly max_size_for_trace_file: {
+                readonly type: "number";
+            };
+            readonly amdp_trace: {
+                readonly type: "boolean";
+            };
+            readonly max_time_for_tracing: {
+                readonly type: "number";
+            };
+        };
+        readonly required: readonly ["target_type"];
+    };
+};
+type HandlerProfileRunArgs = {
+    target_type: 'CLASS' | 'PROGRAM';
+    class_name?: string;
+    program_name?: string;
+    description?: string;
+    all_procedural_units?: boolean;
+    all_misc_abap_statements?: boolean;
+    all_internal_table_events?: boolean;
+    all_dynpro_events?: boolean;
+    aggregate?: boolean;
+    explicit_on_off?: boolean;
+    with_rfc_tracing?: boolean;
+    all_system_kernel_events?: boolean;
+    sql_trace?: boolean;
+    all_db_events?: boolean;
+    max_size_for_trace_file?: number;
+    amdp_trace?: boolean;
+    max_time_for_tracing?: number;
+};
+export declare function handleHandlerProfileRun(context: HandlerContext, args: HandlerProfileRunArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerProfileRun.d.ts.map

package/dist/handlers/compact/high/handleHandlerProfileRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileRun.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerProfileRun.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAKvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,qBAAqB,GAAG;IAC3B,WAAW,EAAE,OAAO,GAAG,SAAS,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,yBAAyB,CAAC,EAAE,OAAO,CAAC;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wBAAwB,CAAC,EAAE,OAAO,CAAC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,qBAAqB;;;;;;GA6C5B"}

package/dist/handlers/compact/high/handleHandlerProfileRun.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerProfileRun = handleHandlerProfileRun;
+const handleRuntimeRunClassWithProfiling_1 = require("../../system/readonly/handleRuntimeRunClassWithProfiling");
+const handleRuntimeRunProgramWithProfiling_1 = require("../../system/readonly/handleRuntimeRunProgramWithProfiling");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerProfileRun',
+    description: 'Compact runtime profiling run. Executes CLASS or PROGRAM with profiling enabled.',
+    inputSchema: compactSchemas_1.compactProfileRunSchema,
+};
+async function handleHandlerProfileRun(context, args) {
+    if (args.target_type === 'CLASS') {
+        if (!args.class_name) {
+            throw new Error('class_name is required when target_type is CLASS');
+        }
+        return (0, handleRuntimeRunClassWithProfiling_1.handleRuntimeRunClassWithProfiling)(context, {
+            class_name: args.class_name,
+            description: args.description,
+            all_procedural_units: args.all_procedural_units,
+            all_misc_abap_statements: args.all_misc_abap_statements,
+            all_internal_table_events: args.all_internal_table_events,
+            all_dynpro_events: args.all_dynpro_events,
+            aggregate: args.aggregate,
+            explicit_on_off: args.explicit_on_off,
+            with_rfc_tracing: args.with_rfc_tracing,
+            all_system_kernel_events: args.all_system_kernel_events,
+            sql_trace: args.sql_trace,
+            all_db_events: args.all_db_events,
+            max_size_for_trace_file: args.max_size_for_trace_file,
+            amdp_trace: args.amdp_trace,
+            max_time_for_tracing: args.max_time_for_tracing,
+        });
+    }
+    if (!args.program_name) {
+        throw new Error('program_name is required when target_type is PROGRAM');
+    }
+    return (0, handleRuntimeRunProgramWithProfiling_1.handleRuntimeRunProgramWithProfiling)(context, {
+        program_name: args.program_name,
+        description: args.description,
+        all_procedural_units: args.all_procedural_units,
+        all_misc_abap_statements: args.all_misc_abap_statements,
+        all_internal_table_events: args.all_internal_table_events,
+        all_dynpro_events: args.all_dynpro_events,
+        aggregate: args.aggregate,
+        explicit_on_off: args.explicit_on_off,
+        with_rfc_tracing: args.with_rfc_tracing,
+        all_system_kernel_events: args.all_system_kernel_events,
+        sql_trace: args.sql_trace,
+        all_db_events: args.all_db_events,
+        max_size_for_trace_file: args.max_size_for_trace_file,
+        amdp_trace: args.amdp_trace,
+        max_time_for_tracing: args.max_time_for_tracing,
+    });
+}
+//# sourceMappingURL=handleHandlerProfileRun.js.map

package/dist/handlers/compact/high/handleHandlerProfileRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileRun.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerProfileRun.ts"],"names":[],"mappings":";;;AAgCA,0DA+CC;AA9ED,iHAA8G;AAC9G,qHAAkH;AAClH,qDAA2D;AAE9C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,mBAAmB;IACzB,WAAW,EACT,kFAAkF;IACpF,WAAW,EAAE,wCAAuB;CAC5B,CAAC;AAsBJ,KAAK,UAAU,uBAAuB,CAC3C,OAAuB,EACvB,IAA2B;IAE3B,IAAI,IAAI,CAAC,WAAW,KAAK,OAAO,EAAE,CAAC;QACjC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QACD,OAAO,IAAA,uEAAkC,EAAC,OAAO,EAAE;YACjD,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;YACvD,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;YACzD,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;YACvD,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;YACrD,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;SAChD,CAAC,CAAC;IACL,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;IACD,OAAO,IAAA,2EAAoC,EAAC,OAAO,EAAE;QACnD,YAAY,EAAE,IAAI,CAAC,YAAY;QAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;QAC/C,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;QACvD,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;QACzD,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;QACzC,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,eAAe,EAAE,IAAI,CAAC,eAAe;QACrC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;QACvC,wBAAwB,EAAE,IAAI,CAAC,wBAAwB;QACvD,SAAS,EAAE,IAAI,CAAC,SAAS;QACzB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,uBAAuB,EAAE,IAAI,CAAC,uBAAuB;QACrD,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;KAChD,CAAC,CAAC;AACL,CAAC"}

package/dist/handlers/compact/high/handleHandlerProfileView.d.ts

@@ -0,0 +1,47 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerProfileView";
+    readonly description: "Compact runtime profiling view. Reads one profiler trace by trace_id_or_uri.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly trace_id_or_uri: {
+                readonly type: "string";
+            };
+            readonly view: {
+                readonly type: "string";
+                readonly enum: readonly ["hitlist", "statements", "db_accesses"];
+            };
+            readonly with_system_events: {
+                readonly type: "boolean";
+            };
+            readonly id: {
+                readonly type: "number";
+            };
+            readonly with_details: {
+                readonly type: "boolean";
+            };
+            readonly auto_drill_down_threshold: {
+                readonly type: "number";
+            };
+        };
+        readonly required: readonly ["trace_id_or_uri", "view"];
+    };
+};
+type HandlerProfileViewArgs = {
+    trace_id_or_uri: string;
+    view: 'hitlist' | 'statements' | 'db_accesses';
+    with_system_events?: boolean;
+    id?: number;
+    with_details?: boolean;
+    auto_drill_down_threshold?: number;
+};
+export declare function handleHandlerProfileView(context: HandlerContext, args: HandlerProfileViewArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerProfileView.d.ts.map

package/dist/handlers/compact/high/handleHandlerProfileView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileView.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerProfileView.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,sBAAsB,GAAG;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,SAAS,GAAG,YAAY,GAAG,aAAa,CAAC;IAC/C,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC,CAAC;AAEF,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,sBAAsB;;;;;;GAG7B"}

package/dist/handlers/compact/high/handleHandlerProfileView.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerProfileView = handleHandlerProfileView;
+const handleRuntimeGetProfilerTraceData_1 = require("../../system/readonly/handleRuntimeGetProfilerTraceData");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerProfileView',
+    description: 'Compact runtime profiling view. Reads one profiler trace by trace_id_or_uri.',
+    inputSchema: compactSchemas_1.compactProfileViewSchema,
+};
+async function handleHandlerProfileView(context, args) {
+    return (0, handleRuntimeGetProfilerTraceData_1.handleRuntimeGetProfilerTraceData)(context, args);
+}
+//# sourceMappingURL=handleHandlerProfileView.js.map

package/dist/handlers/compact/high/handleHandlerProfileView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileView.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerProfileView.ts"],"names":[],"mappings":";;;AAoBA,4DAKC;AAxBD,+GAA4G;AAC5G,qDAA4D;AAE/C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EACT,8EAA8E;IAChF,WAAW,EAAE,yCAAwB;CAC7B,CAAC;AAWJ,KAAK,UAAU,wBAAwB,CAC5C,OAAuB,EACvB,IAA4B;IAE5B,OAAO,IAAA,qEAAiC,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC1D,CAAC"}

package/dist/handlers/compact/high/handleHandlerServiceBindingListTypes.d.ts

@@ -0,0 +1,28 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerServiceBindingListTypes";
+    readonly description: "Compact service binding list types. Returns available binding protocol types.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly response_format: {
+                readonly type: "string";
+                readonly enum: readonly ["xml", "json", "plain"];
+                readonly default: "xml";
+            };
+        };
+        readonly required: readonly [];
+    };
+};
+type HandlerServiceBindingListTypesArgs = {
+    response_format?: 'xml' | 'json' | 'plain';
+};
+export declare function handleHandlerServiceBindingListTypes(context: HandlerContext, args: HandlerServiceBindingListTypesArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerServiceBindingListTypes.d.ts.map

package/dist/handlers/compact/high/handleHandlerServiceBindingListTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerServiceBindingListTypes.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerServiceBindingListTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,kCAAkC,GAAG;IACxC,eAAe,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,OAAO,CAAC;CAC5C,CAAC;AAEF,wBAAsB,oCAAoC,CACxD,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,kCAAkC;;;;;;GAGzC"}

package/dist/handlers/compact/high/handleHandlerServiceBindingListTypes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerServiceBindingListTypes = handleHandlerServiceBindingListTypes;
+const handleListServiceBindingTypes_1 = require("../../service_binding/high/handleListServiceBindingTypes");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerServiceBindingListTypes',
+    description: 'Compact service binding list types. Returns available binding protocol types.',
+    inputSchema: compactSchemas_1.compactServiceBindingListTypesSchema,
+};
+async function handleHandlerServiceBindingListTypes(context, args) {
+    return (0, handleListServiceBindingTypes_1.handleListServiceBindingTypes)(context, args);
+}
+//# sourceMappingURL=handleHandlerServiceBindingListTypes.js.map

package/dist/handlers/compact/high/handleHandlerServiceBindingListTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerServiceBindingListTypes.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerServiceBindingListTypes.ts"],"names":[],"mappings":";;;AAeA,oFAKC;AAnBD,4GAAyG;AACzG,qDAAwE;AAE3D,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,gCAAgC;IACtC,WAAW,EACT,+EAA+E;IACjF,WAAW,EAAE,qDAAoC;CACzC,CAAC;AAMJ,KAAK,UAAU,oCAAoC,CACxD,OAAuB,EACvB,IAAwC;IAExC,OAAO,IAAA,6DAA6B,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACtD,CAAC"}

package/dist/handlers/compact/high/handleHandlerServiceBindingValidate.d.ts

@@ -0,0 +1,42 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerServiceBindingValidate";
+    readonly description: "Compact service binding validate. Validates binding and service definition pair.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly service_binding_name: {
+                readonly type: "string";
+            };
+            readonly service_definition_name: {
+                readonly type: "string";
+            };
+            readonly service_binding_version: {
+                readonly type: "string";
+            };
+            readonly package_name: {
+                readonly type: "string";
+            };
+            readonly description: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["service_binding_name", "service_definition_name"];
+    };
+};
+type HandlerServiceBindingValidateArgs = {
+    service_binding_name: string;
+    service_definition_name: string;
+    service_binding_version?: string;
+    package_name?: string;
+    description?: string;
+};
+export declare function handleHandlerServiceBindingValidate(context: HandlerContext, args: HandlerServiceBindingValidateArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerServiceBindingValidate.d.ts.map

package/dist/handlers/compact/high/handleHandlerServiceBindingValidate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerServiceBindingValidate.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerServiceBindingValidate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,iCAAiC,GAAG;IACvC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,uBAAuB,EAAE,MAAM,CAAC;IAChC,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAsB,mCAAmC,CACvD,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,iCAAiC;;;;;;GAGxC"}

package/dist/handlers/compact/high/handleHandlerServiceBindingValidate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerServiceBindingValidate = handleHandlerServiceBindingValidate;
+const handleValidateServiceBinding_1 = require("../../service_binding/high/handleValidateServiceBinding");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerServiceBindingValidate',
+    description: 'Compact service binding validate. Validates binding and service definition pair.',
+    inputSchema: compactSchemas_1.compactServiceBindingValidateSchema,
+};
+async function handleHandlerServiceBindingValidate(context, args) {
+    return (0, handleValidateServiceBinding_1.handleValidateServiceBinding)(context, args);
+}
+//# sourceMappingURL=handleHandlerServiceBindingValidate.js.map

package/dist/handlers/compact/high/handleHandlerServiceBindingValidate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerServiceBindingValidate.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerServiceBindingValidate.ts"],"names":[],"mappings":";;;AAmBA,kFAKC;AAvBD,0GAAuG;AACvG,qDAAuE;AAE1D,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,+BAA+B;IACrC,WAAW,EACT,kFAAkF;IACpF,WAAW,EAAE,oDAAmC;CACxC,CAAC;AAUJ,KAAK,UAAU,mCAAmC,CACvD,OAAuB,EACvB,IAAuC;IAEvC,OAAO,IAAA,2DAA4B,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACrD,CAAC"}

package/dist/handlers/compact/high/handleHandlerTransportCreate.d.ts

@@ -0,0 +1,40 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerTransportCreate";
+    readonly description: "Compact transport create. Creates a new transport request.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly transport_type: {
+                readonly type: "string";
+                readonly enum: readonly ["workbench", "customizing"];
+                readonly default: "workbench";
+            };
+            readonly description: {
+                readonly type: "string";
+            };
+            readonly target_system: {
+                readonly type: "string";
+            };
+            readonly owner: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["description"];
+    };
+};
+type HandlerTransportCreateArgs = {
+    transport_type?: 'workbench' | 'customizing';
+    description: string;
+    target_system?: string;
+    owner?: string;
+};
+export declare function handleHandlerTransportCreate(context: HandlerContext, args: HandlerTransportCreateArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerTransportCreate.d.ts.map

package/dist/handlers/compact/high/handleHandlerTransportCreate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerTransportCreate.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerTransportCreate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC;AAEX,KAAK,0BAA0B,GAAG;IAChC,cAAc,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,0BAA0B;;;;;;GAGjC"}

package/dist/handlers/compact/high/handleHandlerTransportCreate.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerTransportCreate = handleHandlerTransportCreate;
+const handleCreateTransport_1 = require("../../transport/high/handleCreateTransport");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerTransportCreate',
+    description: 'Compact transport create. Creates a new transport request.',
+    inputSchema: compactSchemas_1.compactTransportCreateSchema,
+};
+async function handleHandlerTransportCreate(context, args) {
+    return (0, handleCreateTransport_1.handleCreateTransport)(context, args);
+}
+//# sourceMappingURL=handleHandlerTransportCreate.js.map

package/dist/handlers/compact/high/handleHandlerTransportCreate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerTransportCreate.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerTransportCreate.ts"],"names":[],"mappings":";;;AAiBA,oEAKC;AArBD,sFAAmF;AACnF,qDAAgE;AAEnD,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,wBAAwB;IAC9B,WAAW,EAAE,4DAA4D;IACzE,WAAW,EAAE,6CAA4B;CACjC,CAAC;AASJ,KAAK,UAAU,4BAA4B,CAChD,OAAuB,EACvB,IAAgC;IAEhC,OAAO,IAAA,6CAAqB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC9C,CAAC"}

package/dist/handlers/compact/high/handleHandlerUnitTestResult.d.ts

@@ -0,0 +1,36 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerUnitTestResult";
+    readonly description: "Compact ABAP Unit result. Reads run result by run_id.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly run_id: {
+                readonly type: "string";
+            };
+            readonly with_navigation_uris: {
+                readonly type: "boolean";
+                readonly default: false;
+            };
+            readonly format: {
+                readonly type: "string";
+                readonly enum: readonly ["abapunit", "junit"];
+            };
+        };
+        readonly required: readonly ["run_id"];
+    };
+};
+type HandlerUnitTestResultArgs = {
+    run_id: string;
+    with_navigation_uris?: boolean;
+    format?: 'abapunit' | 'junit';
+};
+export declare function handleHandlerUnitTestResult(context: HandlerContext, args: HandlerUnitTestResultArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerUnitTestResult.d.ts.map

package/dist/handlers/compact/high/handleHandlerUnitTestResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUnitTestResult.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerUnitTestResult.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC;AAEX,KAAK,yBAAyB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC;CAC/B,CAAC;AAEF,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,yBAAyB;;;;;;GAGhC"}

package/dist/handlers/compact/high/handleHandlerUnitTestResult.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerUnitTestResult = handleHandlerUnitTestResult;
+const handleGetUnitTestResult_1 = require("../../unit_test/high/handleGetUnitTestResult");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerUnitTestResult',
+    description: 'Compact ABAP Unit result. Reads run result by run_id.',
+    inputSchema: compactSchemas_1.compactUnitTestResultSchema,
+};
+async function handleHandlerUnitTestResult(context, args) {
+    return (0, handleGetUnitTestResult_1.handleGetUnitTestResult)(context, args);
+}
+//# sourceMappingURL=handleHandlerUnitTestResult.js.map

package/dist/handlers/compact/high/handleHandlerUnitTestResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUnitTestResult.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerUnitTestResult.ts"],"names":[],"mappings":";;;AAgBA,kEAKC;AApBD,0FAAuF;AACvF,qDAA+D;AAElD,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,uBAAuB;IAC7B,WAAW,EAAE,uDAAuD;IACpE,WAAW,EAAE,4CAA2B;CAChC,CAAC;AAQJ,KAAK,UAAU,2BAA2B,CAC/C,OAAuB,EACvB,IAA+B;IAE/B,OAAO,IAAA,iDAAuB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAChD,CAAC"}

package/dist/handlers/compact/high/handleHandlerUnitTestRun.d.ts

@@ -0,0 +1,106 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerUnitTestRun";
+    readonly description: "Compact ABAP Unit run. Starts a test run and returns run_id.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly tests: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly container_class: {
+                            readonly type: "string";
+                        };
+                        readonly test_class: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly required: readonly ["container_class", "test_class"];
+                };
+            };
+            readonly title: {
+                readonly type: "string";
+            };
+            readonly context: {
+                readonly type: "string";
+            };
+            readonly scope: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly own_tests: {
+                        readonly type: "boolean";
+                    };
+                    readonly foreign_tests: {
+                        readonly type: "boolean";
+                    };
+                    readonly add_foreign_tests_as_preview: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+            readonly risk_level: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly harmless: {
+                        readonly type: "boolean";
+                    };
+                    readonly dangerous: {
+                        readonly type: "boolean";
+                    };
+                    readonly critical: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+            readonly duration: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly short: {
+                        readonly type: "boolean";
+                    };
+                    readonly medium: {
+                        readonly type: "boolean";
+                    };
+                    readonly long: {
+                        readonly type: "boolean";
+                    };
+                };
+            };
+        };
+        readonly required: readonly ["tests"];
+    };
+};
+type HandlerUnitTestRunArgs = {
+    tests: Array<{
+        container_class: string;
+        test_class: string;
+    }>;
+    title?: string;
+    context?: string;
+    scope?: {
+        own_tests?: boolean;
+        foreign_tests?: boolean;
+        add_foreign_tests_as_preview?: boolean;
+    };
+    risk_level?: {
+        harmless?: boolean;
+        dangerous?: boolean;
+        critical?: boolean;
+    };
+    duration?: {
+        short?: boolean;
+        medium?: boolean;
+        long?: boolean;
+    };
+};
+export declare function handleHandlerUnitTestRun(context: HandlerContext, args: HandlerUnitTestRunArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerUnitTestRun.d.ts.map

package/dist/handlers/compact/high/handleHandlerUnitTestRun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUnitTestRun.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerUnitTestRun.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC;AAEX,KAAK,sBAAsB,GAAG;IAC5B,KAAK,EAAE,KAAK,CAAC;QACX,eAAe,EAAE,MAAM,CAAC;QACxB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC,CAAC;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE;QACN,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,4BAA4B,CAAC,EAAE,OAAO,CAAC;KACxC,CAAC;IACF,UAAU,CAAC,EAAE;QACX,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IACF,QAAQ,CAAC,EAAE;QACT,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,OAAO,CAAC;KAChB,CAAC;CACH,CAAC;AAEF,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,sBAAsB;;;;;;GAG7B"}

package/dist/handlers/compact/high/handleHandlerUnitTestRun.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerUnitTestRun = handleHandlerUnitTestRun;
+const handleRunUnitTest_1 = require("../../unit_test/high/handleRunUnitTest");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerUnitTestRun',
+    description: 'Compact ABAP Unit run. Starts a test run and returns run_id.',
+    inputSchema: compactSchemas_1.compactUnitTestRunSchema,
+};
+async function handleHandlerUnitTestRun(context, args) {
+    return (0, handleRunUnitTest_1.handleRunUnitTest)(context, args);
+}
+//# sourceMappingURL=handleHandlerUnitTestRun.js.map

package/dist/handlers/compact/high/handleHandlerUnitTestRun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUnitTestRun.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerUnitTestRun.ts"],"names":[],"mappings":";;;AAkCA,4DAKC;AAtCD,8EAA2E;AAC3E,qDAA4D;AAE/C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EAAE,8DAA8D;IAC3E,WAAW,EAAE,yCAAwB;CAC7B,CAAC;AA0BJ,KAAK,UAAU,wBAAwB,CAC5C,OAAuB,EACvB,IAA4B;IAE5B,OAAO,IAAA,qCAAiB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC1C,CAAC"}

package/dist/handlers/compact/high/handleHandlerUnitTestStatus.d.ts

@@ -0,0 +1,31 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerUnitTestStatus";
+    readonly description: "Compact ABAP Unit status. Reads run status by run_id.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly run_id: {
+                readonly type: "string";
+            };
+            readonly with_long_polling: {
+                readonly type: "boolean";
+                readonly default: true;
+            };
+        };
+        readonly required: readonly ["run_id"];
+    };
+};
+type HandlerUnitTestStatusArgs = {
+    run_id: string;
+    with_long_polling?: boolean;
+};
+export declare function handleHandlerUnitTestStatus(context: HandlerContext, args: HandlerUnitTestStatusArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerUnitTestStatus.d.ts.map

package/dist/handlers/compact/high/handleHandlerUnitTestStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerUnitTestStatus.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerUnitTestStatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;CAIlB,CAAC;AAEX,KAAK,yBAAyB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B,CAAC;AAEF,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,yBAAyB;;;;;;GAGhC"}