@mcp-abap-adt/core 2.4.2 → 2.5.0

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

@@ -0,0 +1,63 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerCheckRun";
+    readonly description: "Compact lifecycle check-run operation. Runs syntax check without activation.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly version: {
+                readonly type: "string";
+                readonly enum: readonly ["active", "inactive"];
+                readonly default: "active";
+            };
+            readonly session_id: {
+                readonly type: "string";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                    };
+                };
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Primary object name for lifecycle operation.";
+            };
+        };
+        readonly required: readonly ["object_type", "object_name"];
+    };
+};
+type HandlerCheckRunArgs = {
+    object_type: CompactObjectType;
+    object_name: string;
+    version?: 'active' | 'inactive';
+    session_id?: string;
+    session_state?: {
+        cookies?: string;
+        csrf_token?: string;
+        cookie_store?: Record<string, string>;
+    };
+};
+export declare function handleHandlerCheckRun(context: HandlerContext, args: HandlerCheckRunArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerCheckRun.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerCheckRun.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerCheckRun.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAGvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,mBAAmB,GAAG;IACzB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACvC,CAAC;CACH,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,mBAAmB;;;;;;GAgB1B"}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerCheckRun = handleHandlerCheckRun;
+const handleCheckObject_1 = require("../../common/low/handleCheckObject");
+const compactLifecycleUtils_1 = require("./compactLifecycleUtils");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerCheckRun',
+    description: 'Compact lifecycle check-run operation. Runs syntax check without activation.',
+    inputSchema: compactSchemas_1.compactCheckRunSchema,
+};
+async function handleHandlerCheckRun(context, args) {
+    const lowType = (0, compactLifecycleUtils_1.toLowObjectType)(args.object_type);
+    if (!lowType) {
+        throw new Error(`CheckRun is not supported for object_type: ${args.object_type}`);
+    }
+    return (0, handleCheckObject_1.handleCheckObject)(context, {
+        object_name: args.object_name,
+        object_type: lowType,
+        version: args.version,
+        session_id: args.session_id,
+        session_state: args.session_state,
+    });
+}
+//# sourceMappingURL=handleHandlerCheckRun.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerCheckRun.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerCheckRun.ts"],"names":[],"mappings":";;;AAyBA,sDAkBC;AA1CD,0EAAuE;AACvE,mEAA0D;AAE1D,qDAAyD;AAE5C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,WAAW,EACT,8EAA8E;IAChF,WAAW,EAAE,sCAAqB;CAC1B,CAAC;AAcJ,KAAK,UAAU,qBAAqB,CACzC,OAAuB,EACvB,IAAyB;IAEzB,MAAM,OAAO,GAAG,IAAA,uCAAe,EAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,8CAA8C,IAAI,CAAC,WAAW,EAAE,CACjE,CAAC;IACJ,CAAC;IAED,OAAO,IAAA,qCAAiB,EAAC,OAAO,EAAE;QAChC,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,OAAO;QACpB,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;KAClC,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,95 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerCreate";
+    readonly description: "Compact facade create operation. Routes by object_type to create supported ABAP object types.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly class_name: {
+                readonly type: "string";
+            };
+            readonly program_name: {
+                readonly type: "string";
+            };
+            readonly domain_name: {
+                readonly type: "string";
+            };
+            readonly function_module_name: {
+                readonly type: "string";
+            };
+            readonly function_group_name: {
+                readonly type: "string";
+            };
+            readonly package_name: {
+                readonly type: "string";
+            };
+            readonly description: {
+                readonly type: "string";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+            };
+            readonly source_code: {
+                readonly type: "string";
+            };
+            readonly activate: {
+                readonly type: "boolean";
+            };
+            readonly program_type: {
+                readonly type: "string";
+            };
+            readonly application: {
+                readonly type: "string";
+            };
+            readonly datatype: {
+                readonly type: "string";
+            };
+            readonly length: {
+                readonly type: "number";
+            };
+            readonly decimals: {
+                readonly type: "number";
+            };
+            readonly conversion_exit: {
+                readonly type: "string";
+            };
+            readonly lowercase: {
+                readonly type: "boolean";
+            };
+            readonly sign_exists: {
+                readonly type: "boolean";
+            };
+            readonly value_table: {
+                readonly type: "string";
+            };
+            readonly fixed_values: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly low: {
+                            readonly type: "string";
+                        };
+                        readonly text: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly required: readonly ["low", "text"];
+                };
+            };
+        };
+        readonly required: readonly ["object_type"];
+    };
+};
+type HandlerCreateArgs = {
+    object_type: CompactObjectType;
+} & Record<string, unknown>;
+export declare function handleHandlerCreate(context: HandlerContext, args: HandlerCreateArgs): Promise<unknown>;
+export {};
+//# sourceMappingURL=handleHandlerCreate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerCreate.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerCreate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,iBAAiB,GAAG;IAAE,WAAW,EAAE,iBAAiB,CAAA;CAAE,GAAG,MAAM,CAClE,MAAM,EACN,OAAO,CACR,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,iBAAiB,oBAGxB"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerCreate = handleHandlerCreate;
+const compactRouter_1 = require("./compactRouter");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerCreate',
+    description: 'Compact facade create operation. Routes by object_type to create supported ABAP object types.',
+    inputSchema: compactSchemas_1.compactCreateSchema,
+};
+async function handleHandlerCreate(context, args) {
+    return (0, compactRouter_1.routeCompactOperation)(context, 'create', args);
+}
+//# sourceMappingURL=handleHandlerCreate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerCreate.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerCreate.ts"],"names":[],"mappings":";;;AAiBA,kDAKC;AApBD,mDAAwD;AACxD,qDAAuD;AAE1C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,eAAe;IACrB,WAAW,EACT,+FAA+F;IACjG,WAAW,EAAE,oCAAmB;CACxB,CAAC;AAOJ,KAAK,UAAU,mBAAmB,CACvC,OAAuB,EACvB,IAAuB;IAEvB,OAAO,IAAA,qCAAqB,EAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AACxD,CAAC"}

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

@@ -0,0 +1,41 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerDelete";
+    readonly description: "Compact facade delete operation. Routes by object_type to delete supported ABAP object types.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly class_name: {
+                readonly type: "string";
+            };
+            readonly program_name: {
+                readonly type: "string";
+            };
+            readonly domain_name: {
+                readonly type: "string";
+            };
+            readonly function_module_name: {
+                readonly type: "string";
+            };
+            readonly function_group_name: {
+                readonly type: "string";
+            };
+            readonly transport_request: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly ["object_type"];
+    };
+};
+type HandlerDeleteArgs = {
+    object_type: CompactObjectType;
+} & Record<string, unknown>;
+export declare function handleHandlerDelete(context: HandlerContext, args: HandlerDeleteArgs): Promise<unknown>;
+export {};
+//# sourceMappingURL=handleHandlerDelete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDelete.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerDelete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,iBAAiB,GAAG;IAAE,WAAW,EAAE,iBAAiB,CAAA;CAAE,GAAG,MAAM,CAClE,MAAM,EACN,OAAO,CACR,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,iBAAiB,oBAGxB"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerDelete = handleHandlerDelete;
+const compactRouter_1 = require("./compactRouter");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerDelete',
+    description: 'Compact facade delete operation. Routes by object_type to delete supported ABAP object types.',
+    inputSchema: compactSchemas_1.compactDeleteSchema,
+};
+async function handleHandlerDelete(context, args) {
+    return (0, compactRouter_1.routeCompactOperation)(context, 'delete', args);
+}
+//# sourceMappingURL=handleHandlerDelete.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDelete.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerDelete.ts"],"names":[],"mappings":";;;AAiBA,kDAKC;AApBD,mDAAwD;AACxD,qDAAuD;AAE1C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,eAAe;IACrB,WAAW,EACT,+FAA+F;IACjG,WAAW,EAAE,oCAAmB;CACxB,CAAC;AAOJ,KAAK,UAAU,mBAAmB,CACvC,OAAuB,EACvB,IAAuB;IAEvB,OAAO,IAAA,qCAAqB,EAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,CAAC;AACxD,CAAC"}

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

@@ -0,0 +1,43 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerDumpList";
+    readonly description: "Compact runtime dump list. Returns runtime dumps with filters.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly user: {
+                readonly type: "string";
+            };
+            readonly inlinecount: {
+                readonly type: "string";
+                readonly enum: readonly ["allpages", "none"];
+            };
+            readonly top: {
+                readonly type: "number";
+            };
+            readonly skip: {
+                readonly type: "number";
+            };
+            readonly orderby: {
+                readonly type: "string";
+            };
+        };
+        readonly required: readonly [];
+    };
+};
+type HandlerDumpListArgs = {
+    user?: string;
+    inlinecount?: 'allpages' | 'none';
+    top?: number;
+    skip?: number;
+    orderby?: string;
+};
+export declare function handleHandlerDumpList(context: HandlerContext, args: HandlerDumpListArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerDumpList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpList.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerDumpList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC;AAEX,KAAK,mBAAmB,GAAG;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,mBAAmB;;;;;;GAG1B"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerDumpList = handleHandlerDumpList;
+const handleRuntimeListDumps_1 = require("../../system/readonly/handleRuntimeListDumps");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerDumpList',
+    description: 'Compact runtime dump list. Returns runtime dumps with filters.',
+    inputSchema: compactSchemas_1.compactDumpListSchema,
+};
+async function handleHandlerDumpList(context, args) {
+    return (0, handleRuntimeListDumps_1.handleRuntimeListDumps)(context, args);
+}
+//# sourceMappingURL=handleHandlerDumpList.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpList.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerDumpList.ts"],"names":[],"mappings":";;;AAkBA,sDAKC;AAtBD,yFAAsF;AACtF,qDAAyD;AAE5C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,WAAW,EAAE,gEAAgE;IAC7E,WAAW,EAAE,sCAAqB;CAC1B,CAAC;AAUJ,KAAK,UAAU,qBAAqB,CACzC,OAAuB,EACvB,IAAyB;IAEzB,OAAO,IAAA,+CAAsB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AAC/C,CAAC"}

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

@@ -0,0 +1,32 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerDumpView";
+    readonly description: "Compact runtime dump view. Reads one dump by dump_id.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly dump_id: {
+                readonly type: "string";
+            };
+            readonly view: {
+                readonly type: "string";
+                readonly enum: readonly ["default", "summary", "formatted"];
+                readonly default: "default";
+            };
+        };
+        readonly required: readonly ["dump_id"];
+    };
+};
+type HandlerDumpViewArgs = {
+    dump_id: string;
+    view?: 'default' | 'summary' | 'formatted';
+};
+export declare function handleHandlerDumpView(context: HandlerContext, args: HandlerDumpViewArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerDumpView.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpView.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerDumpView.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAIlB,CAAC;AAEX,KAAK,mBAAmB,GAAG;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;CAC5C,CAAC;AAEF,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,mBAAmB;;;;;;GAG1B"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerDumpView = handleHandlerDumpView;
+const handleRuntimeGetDumpById_1 = require("../../system/readonly/handleRuntimeGetDumpById");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerDumpView',
+    description: 'Compact runtime dump view. Reads one dump by dump_id.',
+    inputSchema: compactSchemas_1.compactDumpViewSchema,
+};
+async function handleHandlerDumpView(context, args) {
+    return (0, handleRuntimeGetDumpById_1.handleRuntimeGetDumpById)(context, args);
+}
+//# sourceMappingURL=handleHandlerDumpView.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerDumpView.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerDumpView.ts"],"names":[],"mappings":";;;AAeA,sDAKC;AAnBD,6FAA0F;AAC1F,qDAAyD;AAE5C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,iBAAiB;IACvB,WAAW,EAAE,uDAAuD;IACpE,WAAW,EAAE,sCAAqB;CAC1B,CAAC;AAOJ,KAAK,UAAU,qBAAqB,CACzC,OAAuB,EACvB,IAAyB;IAEzB,OAAO,IAAA,mDAAwB,EAAC,OAAO,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC"}

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

@@ -0,0 +1,43 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerGet";
+    readonly description: "Compact facade read operation. Routes by object_type to get supported ABAP object types.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly class_name: {
+                readonly type: "string";
+            };
+            readonly program_name: {
+                readonly type: "string";
+            };
+            readonly domain_name: {
+                readonly type: "string";
+            };
+            readonly function_module_name: {
+                readonly type: "string";
+            };
+            readonly function_group_name: {
+                readonly type: "string";
+            };
+            readonly version: {
+                readonly type: "string";
+                readonly enum: readonly ["active", "inactive"];
+                readonly default: "active";
+            };
+        };
+        readonly required: readonly ["object_type"];
+    };
+};
+type HandlerGetArgs = {
+    object_type: CompactObjectType;
+} & Record<string, unknown>;
+export declare function handleHandlerGet(context: HandlerContext, args: HandlerGetArgs): Promise<unknown>;
+export {};
+//# sourceMappingURL=handleHandlerGet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerGet.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerGet.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,cAAc,GAAG;IAAE,WAAW,EAAE,iBAAiB,CAAA;CAAE,GAAG,MAAM,CAC/D,MAAM,EACN,OAAO,CACR,CAAC;AAEF,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,cAAc,oBAGrB"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerGet = handleHandlerGet;
+const compactRouter_1 = require("./compactRouter");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerGet',
+    description: 'Compact facade read operation. Routes by object_type to get supported ABAP object types.',
+    inputSchema: compactSchemas_1.compactGetSchema,
+};
+async function handleHandlerGet(context, args) {
+    return (0, compactRouter_1.routeCompactOperation)(context, 'get', args);
+}
+//# sourceMappingURL=handleHandlerGet.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerGet.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerGet.ts"],"names":[],"mappings":";;;AAiBA,4CAKC;AApBD,mDAAwD;AACxD,qDAAoD;AAEvC,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,YAAY;IAClB,WAAW,EACT,0FAA0F;IAC5F,WAAW,EAAE,iCAAgB;CACrB,CAAC;AAOJ,KAAK,UAAU,gBAAgB,CACpC,OAAuB,EACvB,IAAoB;IAEpB,OAAO,IAAA,qCAAqB,EAAC,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AACrD,CAAC"}

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

@@ -0,0 +1,61 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+import type { CompactObjectType } from './compactObjectTypes';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerLock";
+    readonly description: "Compact lifecycle lock operation. Locks object for subsequent updates.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly super_package: {
+                readonly type: "string";
+            };
+            readonly session_id: {
+                readonly type: "string";
+            };
+            readonly session_state: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly cookies: {
+                        readonly type: "string";
+                    };
+                    readonly csrf_token: {
+                        readonly type: "string";
+                    };
+                    readonly cookie_store: {
+                        readonly type: "object";
+                    };
+                };
+            };
+            readonly object_type: {
+                readonly type: "string";
+                readonly enum: CompactObjectType[];
+                readonly description: "ABAP object type for routed compact operation.";
+            };
+            readonly object_name: {
+                readonly type: "string";
+                readonly description: "Primary object name for lifecycle operation.";
+            };
+        };
+        readonly required: readonly ["object_type", "object_name"];
+    };
+};
+type HandlerLockArgs = {
+    object_type: CompactObjectType;
+    object_name: string;
+    super_package?: string;
+    session_id?: string;
+    session_state?: {
+        cookies?: string;
+        csrf_token?: string;
+        cookie_store?: Record<string, string>;
+    };
+};
+export declare function handleHandlerLock(context: HandlerContext, args: HandlerLockArgs): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+export {};
+//# sourceMappingURL=handleHandlerLock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerLock.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerLock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAGvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC;AAEX,KAAK,eAAe,GAAG;IACrB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACvC,CAAC;CACH,CAAC;AAEF,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,eAAe;;;;;;GAgBtB"}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerLock = handleHandlerLock;
+const handleLockObject_1 = require("../../common/low/handleLockObject");
+const compactLifecycleUtils_1 = require("./compactLifecycleUtils");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerLock',
+    description: 'Compact lifecycle lock operation. Locks object for subsequent updates.',
+    inputSchema: compactSchemas_1.compactLockSchema,
+};
+async function handleHandlerLock(context, args) {
+    const lowType = (0, compactLifecycleUtils_1.toLowObjectType)(args.object_type);
+    if (!lowType) {
+        throw new Error(`Lock is not supported for object_type: ${args.object_type}`);
+    }
+    return (0, handleLockObject_1.handleLockObject)(context, {
+        object_name: args.object_name,
+        object_type: lowType,
+        super_package: args.super_package,
+        session_id: args.session_id,
+        session_state: args.session_state,
+    });
+}
+//# sourceMappingURL=handleHandlerLock.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerLock.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerLock.ts"],"names":[],"mappings":";;;AAyBA,8CAkBC;AA1CD,wEAAqE;AACrE,mEAA0D;AAE1D,qDAAqD;AAExC,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,aAAa;IACnB,WAAW,EACT,wEAAwE;IAC1E,WAAW,EAAE,kCAAiB;CACtB,CAAC;AAcJ,KAAK,UAAU,iBAAiB,CACrC,OAAuB,EACvB,IAAqB;IAErB,MAAM,OAAO,GAAG,IAAA,uCAAe,EAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,0CAA0C,IAAI,CAAC,WAAW,EAAE,CAC7D,CAAC;IACJ,CAAC;IAED,OAAO,IAAA,mCAAgB,EAAC,OAAO,EAAE;QAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;QAC7B,WAAW,EAAE,OAAO;QACpB,aAAa,EAAE,IAAI,CAAC,aAAa;QACjC,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,aAAa,EAAE,IAAI,CAAC,aAAa;KAClC,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { HandlerContext } from '../../../lib/handlers/interfaces';
+export declare const TOOL_DEFINITION: {
+    readonly name: "HandlerProfileList";
+    readonly description: "Compact runtime profiling list. Returns available profiler traces.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+        readonly required: readonly [];
+    };
+};
+export declare function handleHandlerProfileList(context: HandlerContext): Promise<{
+    isError: boolean;
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;
+//# sourceMappingURL=handleHandlerProfileList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileList.d.ts","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerProfileList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAIvE,eAAO,MAAM,eAAe;;;;;;;;CAKlB,CAAC;AAEX,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,cAAc;;;;;;GAErE"}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITION = void 0;
+exports.handleHandlerProfileList = handleHandlerProfileList;
+const handleRuntimeListProfilerTraceFiles_1 = require("../../system/readonly/handleRuntimeListProfilerTraceFiles");
+const compactSchemas_1 = require("./compactSchemas");
+exports.TOOL_DEFINITION = {
+    name: 'HandlerProfileList',
+    description: 'Compact runtime profiling list. Returns available profiler traces.',
+    inputSchema: compactSchemas_1.compactProfileListSchema,
+};
+async function handleHandlerProfileList(context) {
+    return (0, handleRuntimeListProfilerTraceFiles_1.handleRuntimeListProfilerTraceFiles)(context);
+}
+//# sourceMappingURL=handleHandlerProfileList.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handleHandlerProfileList.js","sourceRoot":"","sources":["../../../../src/handlers/compact/high/handleHandlerProfileList.ts"],"names":[],"mappings":";;;AAWA,4DAEC;AAZD,mHAAgH;AAChH,qDAA4D;AAE/C,QAAA,eAAe,GAAG;IAC7B,IAAI,EAAE,oBAAoB;IAC1B,WAAW,EACT,oEAAoE;IACtE,WAAW,EAAE,yCAAwB;CAC7B,CAAC;AAEJ,KAAK,UAAU,wBAAwB,CAAC,OAAuB;IACpE,OAAO,IAAA,yEAAmC,EAAC,OAAO,CAAC,CAAC;AACtD,CAAC"}