@huaqiu/hqeda 0.1.1 → 0.1.2

package/dist/index.cjs

@@ -0,0 +1,2044 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SKILLS: () => SKILLS,
+  getSkill: () => getSkill,
+  listSkills: () => listSkills,
+  toJson: () => import_huaqiu_client.toJson,
+  toJsonString: () => import_huaqiu_client.toJsonString
+});
+module.exports = __toCommonJS(index_exports);
+
+// generated/common/runtime.ts
+function defineSkill(def) {
+  return def;
+}
+var REGISTRY = /* @__PURE__ */ new Map();
+function registerSkill(skill) {
+  if (REGISTRY.has(skill.id)) {
+    throw new Error(`Duplicate skill id: ${skill.id}`);
+  }
+  REGISTRY.set(skill.id, skill);
+  return skill;
+}
+
+// generated/ai/execute-prompt.ts
+var import_connect = require("@hqedge/connect");
+var ExecutePromptSkill = defineSkill({
+  id: "ai-execute-prompt",
+  title: "Execute Prompt",
+  description: "Execute Prompt via AIService.ExecutePrompt",
+  domain: "ai",
+  service: "AIService",
+  method: "ExecutePrompt",
+  isStreaming: false,
+  inputSchema: import_connect.HqServicesV1AiService.AIRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.ai.executePrompt(input);
+  }
+});
+registerSkill(ExecutePromptSkill);
+
+// generated/bom/get-bom.ts
+var import_connect2 = require("@hqedge/connect");
+var GetBomSkill = defineSkill({
+  id: "bom-get-bom",
+  title: "Get Bom",
+  description: "Get full BOM snapshot from current schematic state",
+  domain: "bom",
+  service: "EdaBomService",
+  method: "GetBom",
+  isStreaming: false,
+  inputSchema: import_connect2.HqFabV1GetEdaBom.GetBomRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.edaBom.getBom(input);
+  }
+});
+registerSkill(GetBomSkill);
+
+// generated/canvas/align-objects.ts
+var import_connect3 = require("@hqedge/connect");
+var AlignObjectsSkill = defineSkill({
+  id: "canvas-align-objects",
+  title: "Align Objects",
+  description: "transform",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "AlignObjects",
+  isStreaming: false,
+  inputSchema: import_connect3.HqServicesV1CanvasOpsService.AlignModeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.alignObjects(input);
+  }
+});
+registerSkill(AlignObjectsSkill);
+
+// generated/canvas/can-paste.ts
+var import_connect4 = require("@hqedge/connect");
+var CanPasteSkill = defineSkill({
+  id: "canvas-can-paste",
+  title: "Can Paste",
+  description: "Can Paste via CanvasOpsService.CanPaste",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "CanPaste",
+  isStreaming: false,
+  inputSchema: import_connect4.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.canPaste(input);
+  }
+});
+registerSkill(CanPasteSkill);
+
+// generated/canvas/clear-all-sel.ts
+var import_connect5 = require("@hqedge/connect");
+var ClearAllSelSkill = defineSkill({
+  id: "canvas-clear-all-sel",
+  title: "Clear All Sel",
+  description: "selection",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ClearAllSel",
+  isStreaming: false,
+  inputSchema: import_connect5.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.clearAllSel(input);
+  }
+});
+registerSkill(ClearAllSelSkill);
+
+// generated/canvas/copy-selected.ts
+var import_connect6 = require("@hqedge/connect");
+var CopySelectedSkill = defineSkill({
+  id: "canvas-copy-selected",
+  title: "Copy Selected",
+  description: "Copy Selected via CanvasOpsService.CopySelected",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "CopySelected",
+  isStreaming: false,
+  inputSchema: import_connect6.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.copySelected(input);
+  }
+});
+registerSkill(CopySelectedSkill);
+
+// generated/canvas/delete-selected.ts
+var import_connect7 = require("@hqedge/connect");
+var DeleteSelectedSkill = defineSkill({
+  id: "canvas-delete-selected",
+  title: "Delete Selected",
+  description: "edit",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "DeleteSelected",
+  isStreaming: false,
+  inputSchema: import_connect7.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.deleteSelected(input);
+  }
+});
+registerSkill(DeleteSelectedSkill);
+
+// generated/canvas/distribute-objects.ts
+var import_connect8 = require("@hqedge/connect");
+var DistributeObjectsSkill = defineSkill({
+  id: "canvas-distribute-objects",
+  title: "Distribute Objects",
+  description: "Distribute Objects via CanvasOpsService.DistributeObjects",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "DistributeObjects",
+  isStreaming: false,
+  inputSchema: import_connect8.HqServicesV1CanvasOpsService.AlignModeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.distributeObjects(input);
+  }
+});
+registerSkill(DistributeObjectsSkill);
+
+// generated/canvas/get-align-type.ts
+var import_connect9 = require("@hqedge/connect");
+var GetAlignTypeSkill = defineSkill({
+  id: "canvas-get-align-type",
+  title: "Get Align Type",
+  description: "Get Align Type via CanvasOpsService.GetAlignType",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "GetAlignType",
+  isStreaming: false,
+  inputSchema: import_connect9.HqServicesV1CanvasOpsService.GetAlignTypeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.getAlignType(input);
+  }
+});
+registerSkill(GetAlignTypeSkill);
+
+// generated/canvas/get-selected-object-json.ts
+var import_connect10 = require("@hqedge/connect");
+var GetSelectedObjectJsonSkill = defineSkill({
+  id: "canvas-get-selected-object-json",
+  title: "Get Selected Object Json",
+  description: "Get Selected Object Json via CanvasOpsService.GetSelectedObjectJson",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "GetSelectedObjectJson",
+  isStreaming: false,
+  inputSchema: import_connect10.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.getSelectedObjectJson(input);
+  }
+});
+registerSkill(GetSelectedObjectJsonSkill);
+
+// generated/canvas/get-selected-objects-json.ts
+var import_connect11 = require("@hqedge/connect");
+var GetSelectedObjectsJsonSkill = defineSkill({
+  id: "canvas-get-selected-objects-json",
+  title: "Get Selected Objects Json",
+  description: "Get Selected Objects Json via CanvasOpsService.GetSelectedObjectsJson",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "GetSelectedObjectsJson",
+  isStreaming: false,
+  inputSchema: import_connect11.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.getSelectedObjectsJson(input);
+  }
+});
+registerSkill(GetSelectedObjectsJsonSkill);
+
+// generated/canvas/mirror-objects.ts
+var import_connect12 = require("@hqedge/connect");
+var MirrorObjectsSkill = defineSkill({
+  id: "canvas-mirror-objects",
+  title: "Mirror Objects",
+  description: "Mirror Objects via CanvasOpsService.MirrorObjects",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "MirrorObjects",
+  isStreaming: false,
+  inputSchema: import_connect12.HqServicesV1CanvasOpsService.AlignModeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.mirrorObjects(input);
+  }
+});
+registerSkill(MirrorObjectsSkill);
+
+// generated/canvas/move-selected-objs.ts
+var import_connect13 = require("@hqedge/connect");
+var MoveSelectedObjsSkill = defineSkill({
+  id: "canvas-move-selected-objs",
+  title: "Move Selected Objs",
+  description: "Move Selected Objs via CanvasOpsService.MoveSelectedObjs",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "MoveSelectedObjs",
+  isStreaming: false,
+  inputSchema: import_connect13.HqServicesV1CanvasOpsService.MoveSelectedObjsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.moveSelectedObjs(input);
+  }
+});
+registerSkill(MoveSelectedObjsSkill);
+
+// generated/canvas/on-canvas-escape.ts
+var import_connect14 = require("@hqedge/connect");
+var OnCanvasEscapeSkill = defineSkill({
+  id: "canvas-on-canvas-escape",
+  title: "On Canvas Escape",
+  description: "state",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "OnCanvasEscape",
+  isStreaming: false,
+  inputSchema: import_connect14.HqServicesV1CanvasOpsService.OnCanvasEscapeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.onCanvasEscape(input);
+  }
+});
+registerSkill(OnCanvasEscapeSkill);
+
+// generated/canvas/pan-canvas.ts
+var import_connect15 = require("@hqedge/connect");
+var PanCanvasSkill = defineSkill({
+  id: "canvas-pan-canvas",
+  title: "Pan Canvas",
+  description: "viewport",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "PanCanvas",
+  isStreaming: false,
+  inputSchema: import_connect15.HqServicesV1CanvasOpsService.PanCanvasRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.panCanvas(input);
+  }
+});
+registerSkill(PanCanvasSkill);
+
+// generated/canvas/paste-selected.ts
+var import_connect16 = require("@hqedge/connect");
+var PasteSelectedSkill = defineSkill({
+  id: "canvas-paste-selected",
+  title: "Paste Selected",
+  description: "Paste Selected via CanvasOpsService.PasteSelected",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "PasteSelected",
+  isStreaming: false,
+  inputSchema: import_connect16.HqServicesV1CanvasOpsService.PasteRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.pasteSelected(input);
+  }
+});
+registerSkill(PasteSelectedSkill);
+
+// generated/canvas/rotate-objects.ts
+var import_connect17 = require("@hqedge/connect");
+var RotateObjectsSkill = defineSkill({
+  id: "canvas-rotate-objects",
+  title: "Rotate Objects",
+  description: "Rotate Objects via CanvasOpsService.RotateObjects",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "RotateObjects",
+  isStreaming: false,
+  inputSchema: import_connect17.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.rotateObjects(input);
+  }
+});
+registerSkill(RotateObjectsSkill);
+
+// generated/canvas/screen-to-canvas-local.ts
+var import_connect18 = require("@hqedge/connect");
+var ScreenToCanvasLocalSkill = defineSkill({
+  id: "canvas-screen-to-canvas-local",
+  title: "Screen To Canvas Local",
+  description: "coordinate",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ScreenToCanvasLocal",
+  isStreaming: false,
+  inputSchema: import_connect18.HqServicesV1CanvasOpsService.ScreenToCanvasLocalRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.screenToCanvasLocal(input);
+  }
+});
+registerSkill(ScreenToCanvasLocalSkill);
+
+// generated/canvas/select-all.ts
+var import_connect19 = require("@hqedge/connect");
+var SelectAllSkill = defineSkill({
+  id: "canvas-select-all",
+  title: "Select All",
+  description: "Select All via CanvasOpsService.SelectAll",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "SelectAll",
+  isStreaming: false,
+  inputSchema: import_connect19.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.selectAll(input);
+  }
+});
+registerSkill(SelectAllSkill);
+
+// generated/canvas/select-object-at.ts
+var import_connect20 = require("@hqedge/connect");
+var SelectObjectAtSkill = defineSkill({
+  id: "canvas-select-object-at",
+  title: "Select Object At",
+  description: "Select Object At via CanvasOpsService.SelectObjectAt",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "SelectObjectAt",
+  isStreaming: false,
+  inputSchema: import_connect20.HqServicesV1CanvasOpsService.WindowClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.selectObjectAt(input);
+  }
+});
+registerSkill(SelectObjectAtSkill);
+
+// generated/canvas/set-align-type.ts
+var import_connect21 = require("@hqedge/connect");
+var SetAlignTypeSkill = defineSkill({
+  id: "canvas-set-align-type",
+  title: "Set Align Type",
+  description: "grid align",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "SetAlignType",
+  isStreaming: false,
+  inputSchema: import_connect21.HqServicesV1CanvasOpsService.SetAlignTypeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.setAlignType(input);
+  }
+});
+registerSkill(SetAlignTypeSkill);
+
+// generated/canvas/set-page-size.ts
+var import_connect22 = require("@hqedge/connect");
+var SetPageSizeSkill = defineSkill({
+  id: "canvas-set-page-size",
+  title: "Set Page Size",
+  description: "page",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "SetPageSize",
+  isStreaming: false,
+  inputSchema: import_connect22.HqServicesV1CanvasOpsService.SetPageSizeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.setPageSize(input);
+  }
+});
+registerSkill(SetPageSizeSkill);
+
+// generated/canvas/set-page-size-rect.ts
+var import_connect23 = require("@hqedge/connect");
+var SetPageSizeRectSkill = defineSkill({
+  id: "canvas-set-page-size-rect",
+  title: "Set Page Size Rect",
+  description: "Set Page Size Rect via CanvasOpsService.SetPageSizeRect",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "SetPageSizeRect",
+  isStreaming: false,
+  inputSchema: import_connect23.HqServicesV1CanvasOpsService.SetPageSizeRectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.setPageSizeRect(input);
+  }
+});
+registerSkill(SetPageSizeRectSkill);
+
+// generated/canvas/zoom-all.ts
+var import_connect24 = require("@hqedge/connect");
+var ZoomAllSkill = defineSkill({
+  id: "canvas-zoom-all",
+  title: "Zoom All",
+  description: "Zoom All via CanvasOpsService.ZoomAll",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomAll",
+  isStreaming: false,
+  inputSchema: import_connect24.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAll(input);
+  }
+});
+registerSkill(ZoomAllSkill);
+
+// generated/canvas/zoom-area-by-double-box.ts
+var import_connect25 = require("@hqedge/connect");
+var ZoomAreaByDoubleBoxSkill = defineSkill({
+  id: "canvas-zoom-area-by-double-box",
+  title: "Zoom Area By Double Box",
+  description: "Zoom Area By Double Box via CanvasOpsService.ZoomAreaByDoubleBox",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomAreaByDoubleBox",
+  isStreaming: false,
+  inputSchema: import_connect25.HqServicesV1CanvasOpsService.ZoomAreaDoubleBoxRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAreaByDoubleBox(input);
+  }
+});
+registerSkill(ZoomAreaByDoubleBoxSkill);
+
+// generated/canvas/zoom-area-by-int-box.ts
+var import_connect26 = require("@hqedge/connect");
+var ZoomAreaByIntBoxSkill = defineSkill({
+  id: "canvas-zoom-area-by-int-box",
+  title: "Zoom Area By Int Box",
+  description: "Zoom Area By Int Box via CanvasOpsService.ZoomAreaByIntBox",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomAreaByIntBox",
+  isStreaming: false,
+  inputSchema: import_connect26.HqServicesV1CanvasOpsService.ZoomAreaIntBoxRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAreaByIntBox(input);
+  }
+});
+registerSkill(ZoomAreaByIntBoxSkill);
+
+// generated/canvas/zoom-area-by-points.ts
+var import_connect27 = require("@hqedge/connect");
+var ZoomAreaByPointsSkill = defineSkill({
+  id: "canvas-zoom-area-by-points",
+  title: "Zoom Area By Points",
+  description: "Zoom Area By Points via CanvasOpsService.ZoomAreaByPoints",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomAreaByPoints",
+  isStreaming: false,
+  inputSchema: import_connect27.HqServicesV1CanvasOpsService.ZoomAreaPointsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAreaByPoints(input);
+  }
+});
+registerSkill(ZoomAreaByPointsSkill);
+
+// generated/canvas/zoom-in.ts
+var import_connect28 = require("@hqedge/connect");
+var ZoomInSkill = defineSkill({
+  id: "canvas-zoom-in",
+  title: "Zoom In",
+  description: "zoom",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomIn",
+  isStreaming: false,
+  inputSchema: import_connect28.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomIn(input);
+  }
+});
+registerSkill(ZoomInSkill);
+
+// generated/canvas/zoom-out.ts
+var import_connect29 = require("@hqedge/connect");
+var ZoomOutSkill = defineSkill({
+  id: "canvas-zoom-out",
+  title: "Zoom Out",
+  description: "Zoom Out via CanvasOpsService.ZoomOut",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomOut",
+  isStreaming: false,
+  inputSchema: import_connect29.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomOut(input);
+  }
+});
+registerSkill(ZoomOutSkill);
+
+// generated/canvas/zoom-selected.ts
+var import_connect30 = require("@hqedge/connect");
+var ZoomSelectedSkill = defineSkill({
+  id: "canvas-zoom-selected",
+  title: "Zoom Selected",
+  description: "Zoom Selected via CanvasOpsService.ZoomSelected",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomSelected",
+  isStreaming: false,
+  inputSchema: import_connect30.HqServicesV1CanvasOpsService.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomSelected(input);
+  }
+});
+registerSkill(ZoomSelectedSkill);
+
+// generated/capability/get-capabilities.ts
+var import_connect31 = require("@hqedge/connect");
+var GetCapabilitiesSkill = defineSkill({
+  id: "capability-get-capabilities",
+  title: "Get Capabilities",
+  description: "Get Capabilities via CapabilityService.GetCapabilities",
+  domain: "capability",
+  service: "CapabilityService",
+  method: "GetCapabilities",
+  isStreaming: false,
+  inputSchema: import_connect31.HqServicesV1CapabilityService.GetCapabilitiesRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.capability.getCapabilities(input);
+  }
+});
+registerSkill(GetCapabilitiesSkill);
+
+// generated/context/get-context.ts
+var import_connect32 = require("@hqedge/connect");
+var GetContextSkill = defineSkill({
+  id: "context-get-context",
+  title: "Get Context",
+  description: "Get Context via ContextService.GetContext",
+  domain: "context",
+  service: "ContextService",
+  method: "GetContext",
+  isStreaming: false,
+  inputSchema: import_connect32.HqServicesV1ContextService.GetContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.context.getContext(input);
+  }
+});
+registerSkill(GetContextSkill);
+
+// generated/discovery/get-server-info.ts
+var import_connect33 = require("@hqedge/connect");
+var GetServerInfoSkill = defineSkill({
+  id: "discovery-get-server-info",
+  title: "Get Server Info",
+  description: "Get Server Info via DiscoveryService.GetServerInfo",
+  domain: "discovery",
+  service: "DiscoveryService",
+  method: "GetServerInfo",
+  isStreaming: false,
+  inputSchema: import_connect33.HqDiscoveryV1Discovery.GetServerInfoRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.discovery.getServerInfo(input);
+  }
+});
+registerSkill(GetServerInfoSkill);
+
+// generated/erc/clear-all-findings.ts
+var import_connect34 = require("@hqedge/connect");
+var ClearAllFindingsSkill = defineSkill({
+  id: "erc-clear-all-findings",
+  title: "Clear All Findings",
+  description: "Clear All Findings via ERCService.ClearAllFindings",
+  domain: "erc",
+  service: "ERCService",
+  method: "ClearAllFindings",
+  isStreaming: false,
+  inputSchema: import_connect34.HqServicesV1ErcService.ClearAllFindingsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.clearAllFindings(input);
+  }
+});
+registerSkill(ClearAllFindingsSkill);
+
+// generated/erc/clear-findings.ts
+var import_connect35 = require("@hqedge/connect");
+var ClearFindingsSkill = defineSkill({
+  id: "erc-clear-findings",
+  title: "Clear Findings",
+  description: "Clear Findings via ERCService.ClearFindings",
+  domain: "erc",
+  service: "ERCService",
+  method: "ClearFindings",
+  isStreaming: false,
+  inputSchema: import_connect35.HqServicesV1ErcService.ClearFindingsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.clearFindings(input);
+  }
+});
+registerSkill(ClearFindingsSkill);
+
+// generated/erc/run-checks.ts
+var import_connect36 = require("@hqedge/connect");
+var RunChecksSkill = defineSkill({
+  id: "erc-run-checks",
+  title: "Run Checks",
+  description: "Run erc check with the eda's built-in engine",
+  domain: "erc",
+  service: "ERCService",
+  method: "RunChecks",
+  isStreaming: false,
+  inputSchema: import_connect36.HqServicesV1ErcService.RunChecksRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.runChecks(input);
+  }
+});
+registerSkill(RunChecksSkill);
+
+// generated/erc/set-erc-report-webview-visibility.ts
+var import_connect37 = require("@hqedge/connect");
+var SetErcReportWebviewVisibilitySkill = defineSkill({
+  id: "erc-set-erc-report-webview-visibility",
+  title: "Set Erc Report Webview Visibility",
+  description: "ONLY controls report webview visibility",
+  domain: "erc",
+  service: "ERCService",
+  method: "SetErcReportWebviewVisibility",
+  isStreaming: false,
+  inputSchema: import_connect37.HqServicesV1ErcService.SetErcReportWebviewVisibilityRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.setErcReportWebviewVisibility(input);
+  }
+});
+registerSkill(SetErcReportWebviewVisibilitySkill);
+
+// generated/erc/set-report-webview-state.ts
+var import_connect38 = require("@hqedge/connect");
+var SetReportWebviewStateSkill = defineSkill({
+  id: "erc-set-report-webview-state",
+  title: "Set Report Webview State",
+  description: "Set Report Webview State via ERCService.SetReportWebviewState",
+  domain: "erc",
+  service: "ERCService",
+  method: "SetReportWebviewState",
+  isStreaming: false,
+  inputSchema: import_connect38.HqServicesV1ErcService.SetReportWebviewStateRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.setReportWebviewState(input);
+  }
+});
+registerSkill(SetReportWebviewStateSkill);
+
+// generated/erc/show-findings.ts
+var import_connect39 = require("@hqedge/connect");
+var ShowFindingsSkill = defineSkill({
+  id: "erc-show-findings",
+  title: "Show Findings",
+  description: "Canvas interaction (row click \u2192 highlight in EDA view)",
+  domain: "erc",
+  service: "ERCService",
+  method: "ShowFindings",
+  isStreaming: false,
+  inputSchema: import_connect39.HqServicesV1ErcService.ShowFindingsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.showFindings(input);
+  }
+});
+registerSkill(ShowFindingsSkill);
+
+// generated/event/subscribe.ts
+var import_connect40 = require("@hqedge/connect");
+var SubscribeSkill = defineSkill({
+  id: "event-subscribe",
+  title: "Subscribe",
+  description: "Subscribe via EventService.Subscribe",
+  domain: "event",
+  service: "EventService",
+  method: "Subscribe",
+  isStreaming: true,
+  inputSchema: import_connect40.HqServicesV1EventService.SubscribeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.event.subscribe(input);
+  }
+});
+registerSkill(SubscribeSkill);
+
+// generated/export/export-bom.ts
+var import_connect41 = require("@hqedge/connect");
+var ExportBOMSkill = defineSkill({
+  id: "export-export-bom",
+  title: "Export Bom",
+  description: "Export Bom via ExportService.ExportBOM",
+  domain: "export",
+  service: "ExportService",
+  method: "ExportBOM",
+  isStreaming: false,
+  inputSchema: import_connect41.HqServicesV1ExportService.ExportBOMRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.export.exportBOM(input);
+  }
+});
+registerSkill(ExportBOMSkill);
+
+// generated/export/export-target.ts
+var import_connect42 = require("@hqedge/connect");
+var ExportTargetSkill = defineSkill({
+  id: "export-export-target",
+  title: "Export Target",
+  description: "Export Target via ExportService.ExportTarget",
+  domain: "export",
+  service: "ExportService",
+  method: "ExportTarget",
+  isStreaming: false,
+  inputSchema: import_connect42.HqServicesV1ExportService.ExportTargetRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.export.exportTarget(input);
+  }
+});
+registerSkill(ExportTargetSkill);
+
+// generated/graph/get-connectivity.ts
+var import_connect43 = require("@hqedge/connect");
+var GetConnectivitySkill = defineSkill({
+  id: "graph-get-connectivity",
+  title: "Get Connectivity",
+  description: "Get Connectivity via GraphService.GetConnectivity",
+  domain: "graph",
+  service: "GraphService",
+  method: "GetConnectivity",
+  isStreaming: false,
+  inputSchema: import_connect43.HqServicesV1GraphService.ConnectivityRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.graph.getConnectivity(input);
+  }
+});
+registerSkill(GetConnectivitySkill);
+
+// generated/graph/query-graph.ts
+var import_connect44 = require("@hqedge/connect");
+var QueryGraphSkill = defineSkill({
+  id: "graph-query-graph",
+  title: "Query Graph",
+  description: "Query Graph via GraphService.QueryGraph",
+  domain: "graph",
+  service: "GraphService",
+  method: "QueryGraph",
+  isStreaming: false,
+  inputSchema: import_connect44.HqServicesV1GraphService.GraphQueryRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.graph.queryGraph(input);
+  }
+});
+registerSkill(QueryGraphSkill);
+
+// generated/import/import-design.ts
+var import_connect45 = require("@hqedge/connect");
+var ImportDesignSkill = defineSkill({
+  id: "import-import-design",
+  title: "Import Design",
+  description: "Import a design from an external EDA system",
+  domain: "import",
+  service: "ImportService",
+  method: "ImportDesign",
+  isStreaming: false,
+  inputSchema: import_connect45.HqServicesV1ImportService.ImportDesignRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.import.importDesign(input);
+  }
+});
+registerSkill(ImportDesignSkill);
+
+// generated/kernel/get-entity.ts
+var import_connect46 = require("@hqedge/connect");
+var GetEntitySkill = defineSkill({
+  id: "kernel-get-entity",
+  title: "Get Entity",
+  description: "Get Entity via KernelService.GetEntity",
+  domain: "kernel",
+  service: "KernelService",
+  method: "GetEntity",
+  isStreaming: false,
+  inputSchema: import_connect46.HqServicesV1KernelService.GetEntityRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.kernel.getEntity(input);
+  }
+});
+registerSkill(GetEntitySkill);
+
+// generated/kernel/get-snapshot.ts
+var import_connect47 = require("@hqedge/connect");
+var GetSnapshotSkill = defineSkill({
+  id: "kernel-get-snapshot",
+  title: "Get Snapshot",
+  description: "Get Snapshot via KernelService.GetSnapshot",
+  domain: "kernel",
+  service: "KernelService",
+  method: "GetSnapshot",
+  isStreaming: false,
+  inputSchema: import_connect47.HqServicesV1KernelService.GetSnapshotRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.kernel.getSnapshot(input);
+  }
+});
+registerSkill(GetSnapshotSkill);
+
+// generated/obj-place/add-bus-segment.ts
+var import_connect48 = require("@hqedge/connect");
+var AddBusSegmentSkill = defineSkill({
+  id: "obj-place-add-bus-segment",
+  title: "Add Bus Segment",
+  description: "Add Bus Segment via ObjPlaceService.AddBusSegment",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "AddBusSegment",
+  isStreaming: false,
+  inputSchema: import_connect48.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addBusSegment(input);
+  }
+});
+registerSkill(AddBusSegmentSkill);
+
+// generated/obj-place/add-ellipse.ts
+var import_connect49 = require("@hqedge/connect");
+var AddEllipseSkill = defineSkill({
+  id: "obj-place-add-ellipse",
+  title: "Add Ellipse",
+  description: "Add Ellipse via ObjPlaceService.AddEllipse",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "AddEllipse",
+  isStreaming: false,
+  inputSchema: import_connect49.HqServicesV1ObjPlaceService.BoxShiftPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addEllipse(input);
+  }
+});
+registerSkill(AddEllipseSkill);
+
+// generated/obj-place/add-free-line-segment.ts
+var import_connect50 = require("@hqedge/connect");
+var AddFreeLineSegmentSkill = defineSkill({
+  id: "obj-place-add-free-line-segment",
+  title: "Add Free Line Segment",
+  description: "Add Free Line Segment via ObjPlaceService.AddFreeLineSegment",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "AddFreeLineSegment",
+  isStreaming: false,
+  inputSchema: import_connect50.HqServicesV1ObjPlaceService.AddFreeLineSegmentRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addFreeLineSegment(input);
+  }
+});
+registerSkill(AddFreeLineSegmentSkill);
+
+// generated/obj-place/add-line.ts
+var import_connect51 = require("@hqedge/connect");
+var AddLineSkill = defineSkill({
+  id: "obj-place-add-line",
+  title: "Add Line",
+  description: "Add Line via ObjPlaceService.AddLine",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "AddLine",
+  isStreaming: false,
+  inputSchema: import_connect51.HqServicesV1ObjPlaceService.AddLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addLine(input);
+  }
+});
+registerSkill(AddLineSkill);
+
+// generated/obj-place/add-rect.ts
+var import_connect52 = require("@hqedge/connect");
+var AddRectSkill = defineSkill({
+  id: "obj-place-add-rect",
+  title: "Add Rect",
+  description: "Add Rect via ObjPlaceService.AddRect",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "AddRect",
+  isStreaming: false,
+  inputSchema: import_connect52.HqServicesV1ObjPlaceService.BoxPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addRect(input);
+  }
+});
+registerSkill(AddRectSkill);
+
+// generated/obj-place/add-wire-segment.ts
+var import_connect53 = require("@hqedge/connect");
+var AddWireSegmentSkill = defineSkill({
+  id: "obj-place-add-wire-segment",
+  title: "Add Wire Segment",
+  description: "Add Wire Segment via ObjPlaceService.AddWireSegment",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "AddWireSegment",
+  isStreaming: false,
+  inputSchema: import_connect53.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addWireSegment(input);
+  }
+});
+registerSkill(AddWireSegmentSkill);
+
+// generated/obj-place/cancel-bus-draw.ts
+var import_connect54 = require("@hqedge/connect");
+var CancelBusDrawSkill = defineSkill({
+  id: "obj-place-cancel-bus-draw",
+  title: "Cancel Bus Draw",
+  description: "Cancel Bus Draw via ObjPlaceService.CancelBusDraw",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "CancelBusDraw",
+  isStreaming: false,
+  inputSchema: import_connect54.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelBusDraw(input);
+  }
+});
+registerSkill(CancelBusDrawSkill);
+
+// generated/obj-place/cancel-ellipse-arc-draw.ts
+var import_connect55 = require("@hqedge/connect");
+var CancelEllipseArcDrawSkill = defineSkill({
+  id: "obj-place-cancel-ellipse-arc-draw",
+  title: "Cancel Ellipse Arc Draw",
+  description: "Cancel Ellipse Arc Draw via ObjPlaceService.CancelEllipseArcDraw",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "CancelEllipseArcDraw",
+  isStreaming: false,
+  inputSchema: import_connect55.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelEllipseArcDraw(input);
+  }
+});
+registerSkill(CancelEllipseArcDrawSkill);
+
+// generated/obj-place/cancel-ellipse-draw.ts
+var import_connect56 = require("@hqedge/connect");
+var CancelEllipseDrawSkill = defineSkill({
+  id: "obj-place-cancel-ellipse-draw",
+  title: "Cancel Ellipse Draw",
+  description: "Cancel Ellipse Draw via ObjPlaceService.CancelEllipseDraw",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "CancelEllipseDraw",
+  isStreaming: false,
+  inputSchema: import_connect56.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelEllipseDraw(input);
+  }
+});
+registerSkill(CancelEllipseDrawSkill);
+
+// generated/obj-place/cancel-free-line-draw.ts
+var import_connect57 = require("@hqedge/connect");
+var CancelFreeLineDrawSkill = defineSkill({
+  id: "obj-place-cancel-free-line-draw",
+  title: "Cancel Free Line Draw",
+  description: "Cancel Free Line Draw via ObjPlaceService.CancelFreeLineDraw",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "CancelFreeLineDraw",
+  isStreaming: false,
+  inputSchema: import_connect57.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelFreeLineDraw(input);
+  }
+});
+registerSkill(CancelFreeLineDrawSkill);
+
+// generated/obj-place/cancel-line-draw.ts
+var import_connect58 = require("@hqedge/connect");
+var CancelLineDrawSkill = defineSkill({
+  id: "obj-place-cancel-line-draw",
+  title: "Cancel Line Draw",
+  description: "Cancel Line Draw via ObjPlaceService.CancelLineDraw",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "CancelLineDraw",
+  isStreaming: false,
+  inputSchema: import_connect58.HqServicesV1ObjPlaceService.CancelLineDrawRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelLineDraw(input);
+  }
+});
+registerSkill(CancelLineDrawSkill);
+
+// generated/obj-place/cancel-rect-draw.ts
+var import_connect59 = require("@hqedge/connect");
+var CancelRectDrawSkill = defineSkill({
+  id: "obj-place-cancel-rect-draw",
+  title: "Cancel Rect Draw",
+  description: "Cancel Rect Draw via ObjPlaceService.CancelRectDraw",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "CancelRectDraw",
+  isStreaming: false,
+  inputSchema: import_connect59.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelRectDraw(input);
+  }
+});
+registerSkill(CancelRectDrawSkill);
+
+// generated/obj-place/cancel-wire-draw.ts
+var import_connect60 = require("@hqedge/connect");
+var CancelWireDrawSkill = defineSkill({
+  id: "obj-place-cancel-wire-draw",
+  title: "Cancel Wire Draw",
+  description: "Cancel Wire Draw via ObjPlaceService.CancelWireDraw",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "CancelWireDraw",
+  isStreaming: false,
+  inputSchema: import_connect60.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelWireDraw(input);
+  }
+});
+registerSkill(CancelWireDrawSkill);
+
+// generated/obj-place/handle-bus-draw-click.ts
+var import_connect61 = require("@hqedge/connect");
+var HandleBusDrawClickSkill = defineSkill({
+  id: "obj-place-handle-bus-draw-click",
+  title: "Handle Bus Draw Click",
+  description: "bus",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleBusDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect61.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleBusDrawClick(input);
+  }
+});
+registerSkill(HandleBusDrawClickSkill);
+
+// generated/obj-place/handle-ellipse-arc-draw-click.ts
+var import_connect62 = require("@hqedge/connect");
+var HandleEllipseArcDrawClickSkill = defineSkill({
+  id: "obj-place-handle-ellipse-arc-draw-click",
+  title: "Handle Ellipse Arc Draw Click",
+  description: "Handle Ellipse Arc Draw Click via ObjPlaceService.HandleEllipseArcDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleEllipseArcDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect62.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleEllipseArcDrawClick(input);
+  }
+});
+registerSkill(HandleEllipseArcDrawClickSkill);
+
+// generated/obj-place/handle-ellipse-draw-click.ts
+var import_connect63 = require("@hqedge/connect");
+var HandleEllipseDrawClickSkill = defineSkill({
+  id: "obj-place-handle-ellipse-draw-click",
+  title: "Handle Ellipse Draw Click",
+  description: "Handle Ellipse Draw Click via ObjPlaceService.HandleEllipseDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleEllipseDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect63.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleEllipseDrawClick(input);
+  }
+});
+registerSkill(HandleEllipseDrawClickSkill);
+
+// generated/obj-place/handle-free-line-draw-click.ts
+var import_connect64 = require("@hqedge/connect");
+var HandleFreeLineDrawClickSkill = defineSkill({
+  id: "obj-place-handle-free-line-draw-click",
+  title: "Handle Free Line Draw Click",
+  description: "Handle Free Line Draw Click via ObjPlaceService.HandleFreeLineDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleFreeLineDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect64.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleFreeLineDrawClick(input);
+  }
+});
+registerSkill(HandleFreeLineDrawClickSkill);
+
+// generated/obj-place/handle-image-draw-click.ts
+var import_connect65 = require("@hqedge/connect");
+var HandleImageDrawClickSkill = defineSkill({
+  id: "obj-place-handle-image-draw-click",
+  title: "Handle Image Draw Click",
+  description: "Handle Image Draw Click via ObjPlaceService.HandleImageDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleImageDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect65.HqServicesV1ObjPlaceService.HandleImageDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleImageDrawClick(input);
+  }
+});
+registerSkill(HandleImageDrawClickSkill);
+
+// generated/obj-place/handle-line-draw-click.ts
+var import_connect66 = require("@hqedge/connect");
+var HandleLineDrawClickSkill = defineSkill({
+  id: "obj-place-handle-line-draw-click",
+  title: "Handle Line Draw Click",
+  description: "Handle Line Draw Click via ObjPlaceService.HandleLineDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleLineDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect66.HqServicesV1ObjPlaceService.HandleLineDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleLineDrawClick(input);
+  }
+});
+registerSkill(HandleLineDrawClickSkill);
+
+// generated/obj-place/handle-net-alias-draw-click.ts
+var import_connect67 = require("@hqedge/connect");
+var HandleNetAliasDrawClickSkill = defineSkill({
+  id: "obj-place-handle-net-alias-draw-click",
+  title: "Handle Net Alias Draw Click",
+  description: "Handle Net Alias Draw Click via ObjPlaceService.HandleNetAliasDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleNetAliasDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect67.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleNetAliasDrawClick(input);
+  }
+});
+registerSkill(HandleNetAliasDrawClickSkill);
+
+// generated/obj-place/handle-rect-draw-click.ts
+var import_connect68 = require("@hqedge/connect");
+var HandleRectDrawClickSkill = defineSkill({
+  id: "obj-place-handle-rect-draw-click",
+  title: "Handle Rect Draw Click",
+  description: "Handle Rect Draw Click via ObjPlaceService.HandleRectDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleRectDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect68.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleRectDrawClick(input);
+  }
+});
+registerSkill(HandleRectDrawClickSkill);
+
+// generated/obj-place/handle-table-draw-click.ts
+var import_connect69 = require("@hqedge/connect");
+var HandleTableDrawClickSkill = defineSkill({
+  id: "obj-place-handle-table-draw-click",
+  title: "Handle Table Draw Click",
+  description: "Handle Table Draw Click via ObjPlaceService.HandleTableDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleTableDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect69.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleTableDrawClick(input);
+  }
+});
+registerSkill(HandleTableDrawClickSkill);
+
+// generated/obj-place/handle-text-draw-click.ts
+var import_connect70 = require("@hqedge/connect");
+var HandleTextDrawClickSkill = defineSkill({
+  id: "obj-place-handle-text-draw-click",
+  title: "Handle Text Draw Click",
+  description: "Handle Text Draw Click via ObjPlaceService.HandleTextDrawClick",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleTextDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect70.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleTextDrawClick(input);
+  }
+});
+registerSkill(HandleTextDrawClickSkill);
+
+// generated/obj-place/handle-wire-draw-click.ts
+var import_connect71 = require("@hqedge/connect");
+var HandleWireDrawClickSkill = defineSkill({
+  id: "obj-place-handle-wire-draw-click",
+  title: "Handle Wire Draw Click",
+  description: "wire",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "HandleWireDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect71.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleWireDrawClick(input);
+  }
+});
+registerSkill(HandleWireDrawClickSkill);
+
+// generated/obj-place/place-bus.ts
+var import_connect72 = require("@hqedge/connect");
+var PlaceBusSkill = defineSkill({
+  id: "obj-place-place-bus",
+  title: "Place Bus",
+  description: "Place Bus via ObjPlaceService.PlaceBus",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceBus",
+  isStreaming: false,
+  inputSchema: import_connect72.HqServicesV1ObjPlaceService.PlaceLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeBus(input);
+  }
+});
+registerSkill(PlaceBusSkill);
+
+// generated/obj-place/place-ellipse.ts
+var import_connect73 = require("@hqedge/connect");
+var PlaceEllipseSkill = defineSkill({
+  id: "obj-place-place-ellipse",
+  title: "Place Ellipse",
+  description: "ellipse",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceEllipse",
+  isStreaming: false,
+  inputSchema: import_connect73.HqServicesV1ObjPlaceService.BoxShiftPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeEllipse(input);
+  }
+});
+registerSkill(PlaceEllipseSkill);
+
+// generated/obj-place/place-ellipse-arc.ts
+var import_connect74 = require("@hqedge/connect");
+var PlaceEllipseArcSkill = defineSkill({
+  id: "obj-place-place-ellipse-arc",
+  title: "Place Ellipse Arc",
+  description: "ellipse arc",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceEllipseArc",
+  isStreaming: false,
+  inputSchema: import_connect74.HqServicesV1ObjPlaceService.ObjDataPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeEllipseArc(input);
+  }
+});
+registerSkill(PlaceEllipseArcSkill);
+
+// generated/obj-place/place-ellipse-arc-from-virtual.ts
+var import_connect75 = require("@hqedge/connect");
+var PlaceEllipseArcFromVirtualSkill = defineSkill({
+  id: "obj-place-place-ellipse-arc-from-virtual",
+  title: "Place Ellipse Arc From Virtual",
+  description: "Place Ellipse Arc From Virtual via ObjPlaceService.PlaceEllipseArcFromVirtual",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceEllipseArcFromVirtual",
+  isStreaming: false,
+  inputSchema: import_connect75.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeEllipseArcFromVirtual(input);
+  }
+});
+registerSkill(PlaceEllipseArcFromVirtualSkill);
+
+// generated/obj-place/place-free-line.ts
+var import_connect76 = require("@hqedge/connect");
+var PlaceFreeLineSkill = defineSkill({
+  id: "obj-place-place-free-line",
+  title: "Place Free Line",
+  description: "free line",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceFreeLine",
+  isStreaming: false,
+  inputSchema: import_connect76.HqServicesV1ObjPlaceService.PlaceFreeLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeFreeLine(input);
+  }
+});
+registerSkill(PlaceFreeLineSkill);
+
+// generated/obj-place/place-image.ts
+var import_connect77 = require("@hqedge/connect");
+var PlaceImageSkill = defineSkill({
+  id: "obj-place-place-image",
+  title: "Place Image",
+  description: "image",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceImage",
+  isStreaming: false,
+  inputSchema: import_connect77.HqServicesV1ObjPlaceService.PlaceImageRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeImage(input);
+  }
+});
+registerSkill(PlaceImageSkill);
+
+// generated/obj-place/place-line.ts
+var import_connect78 = require("@hqedge/connect");
+var PlaceLineSkill = defineSkill({
+  id: "obj-place-place-line",
+  title: "Place Line",
+  description: "line",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceLine",
+  isStreaming: false,
+  inputSchema: import_connect78.HqServicesV1ObjPlaceService.PlaceLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeLine(input);
+  }
+});
+registerSkill(PlaceLineSkill);
+
+// generated/obj-place/place-net-alias.ts
+var import_connect79 = require("@hqedge/connect");
+var PlaceNetAliasSkill = defineSkill({
+  id: "obj-place-place-net-alias",
+  title: "Place Net Alias",
+  description: "net alias",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceNetAlias",
+  isStreaming: false,
+  inputSchema: import_connect79.HqServicesV1ObjPlaceService.PlaceNetAliasRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeNetAlias(input);
+  }
+});
+registerSkill(PlaceNetAliasSkill);
+
+// generated/obj-place/place-rect.ts
+var import_connect80 = require("@hqedge/connect");
+var PlaceRectSkill = defineSkill({
+  id: "obj-place-place-rect",
+  title: "Place Rect",
+  description: "rect",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceRect",
+  isStreaming: false,
+  inputSchema: import_connect80.HqServicesV1ObjPlaceService.BoxPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeRect(input);
+  }
+});
+registerSkill(PlaceRectSkill);
+
+// generated/obj-place/place-table.ts
+var import_connect81 = require("@hqedge/connect");
+var PlaceTableSkill = defineSkill({
+  id: "obj-place-place-table",
+  title: "Place Table",
+  description: "table",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceTable",
+  isStreaming: false,
+  inputSchema: import_connect81.HqServicesV1ObjPlaceService.ObjDataPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeTable(input);
+  }
+});
+registerSkill(PlaceTableSkill);
+
+// generated/obj-place/place-table-from-virtual.ts
+var import_connect82 = require("@hqedge/connect");
+var PlaceTableFromVirtualSkill = defineSkill({
+  id: "obj-place-place-table-from-virtual",
+  title: "Place Table From Virtual",
+  description: "Place Table From Virtual via ObjPlaceService.PlaceTableFromVirtual",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceTableFromVirtual",
+  isStreaming: false,
+  inputSchema: import_connect82.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeTableFromVirtual(input);
+  }
+});
+registerSkill(PlaceTableFromVirtualSkill);
+
+// generated/obj-place/place-text.ts
+var import_connect83 = require("@hqedge/connect");
+var PlaceTextSkill = defineSkill({
+  id: "obj-place-place-text",
+  title: "Place Text",
+  description: "text",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceText",
+  isStreaming: false,
+  inputSchema: import_connect83.HqServicesV1ObjPlaceService.ObjDataPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeText(input);
+  }
+});
+registerSkill(PlaceTextSkill);
+
+// generated/obj-place/place-text-from-virtual.ts
+var import_connect84 = require("@hqedge/connect");
+var PlaceTextFromVirtualSkill = defineSkill({
+  id: "obj-place-place-text-from-virtual",
+  title: "Place Text From Virtual",
+  description: "Place Text From Virtual via ObjPlaceService.PlaceTextFromVirtual",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceTextFromVirtual",
+  isStreaming: false,
+  inputSchema: import_connect84.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeTextFromVirtual(input);
+  }
+});
+registerSkill(PlaceTextFromVirtualSkill);
+
+// generated/obj-place/place-wire.ts
+var import_connect85 = require("@hqedge/connect");
+var PlaceWireSkill = defineSkill({
+  id: "obj-place-place-wire",
+  title: "Place Wire",
+  description: "Place Wire via ObjPlaceService.PlaceWire",
+  domain: "obj-place",
+  service: "ObjPlaceService",
+  method: "PlaceWire",
+  isStreaming: false,
+  inputSchema: import_connect85.HqServicesV1ObjPlaceService.PlaceLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeWire(input);
+  }
+});
+registerSkill(PlaceWireSkill);
+
+// generated/placement/cancel-block-draw.ts
+var import_connect86 = require("@hqedge/connect");
+var CancelBlockDrawSkill = defineSkill({
+  id: "placement-cancel-block-draw",
+  title: "Cancel Block Draw",
+  description: "Cancel Block Draw via ComponentPlaceService.CancelBlockDraw",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "CancelBlockDraw",
+  isStreaming: false,
+  inputSchema: import_connect86.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.cancelBlockDraw(input);
+  }
+});
+registerSkill(CancelBlockDrawSkill);
+
+// generated/placement/clear-net-alias-attach-obj.ts
+var import_connect87 = require("@hqedge/connect");
+var ClearNetAliasAttachObjSkill = defineSkill({
+  id: "placement-clear-net-alias-attach-obj",
+  title: "Clear Net Alias Attach Obj",
+  description: "Clear Net Alias Attach Obj via ComponentPlaceService.ClearNetAliasAttachObj",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "ClearNetAliasAttachObj",
+  isStreaming: false,
+  inputSchema: import_connect87.HqServicesV1ObjPlaceService.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.clearNetAliasAttachObj(input);
+  }
+});
+registerSkill(ClearNetAliasAttachObjSkill);
+
+// generated/placement/handle-block-draw-click.ts
+var import_connect88 = require("@hqedge/connect");
+var HandleBlockDrawClickSkill = defineSkill({
+  id: "placement-handle-block-draw-click",
+  title: "Handle Block Draw Click",
+  description: "Handle Block Draw Click via ComponentPlaceService.HandleBlockDrawClick",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "HandleBlockDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect88.HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.handleBlockDrawClick(input);
+  }
+});
+registerSkill(HandleBlockDrawClickSkill);
+
+// generated/placement/handle-part-draw-click.ts
+var import_connect89 = require("@hqedge/connect");
+var HandlePartDrawClickSkill = defineSkill({
+  id: "placement-handle-part-draw-click",
+  title: "Handle Part Draw Click",
+  description: "Handle Part Draw Click via ComponentPlaceService.HandlePartDrawClick",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "HandlePartDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect89.HqServicesV1ComponentPlaceService.HandlePartDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.handlePartDrawClick(input);
+  }
+});
+registerSkill(HandlePartDrawClickSkill);
+
+// generated/placement/handle-symbol-draw-click.ts
+var import_connect90 = require("@hqedge/connect");
+var HandleSymbolDrawClickSkill = defineSkill({
+  id: "placement-handle-symbol-draw-click",
+  title: "Handle Symbol Draw Click",
+  description: "Handle Symbol Draw Click via ComponentPlaceService.HandleSymbolDrawClick",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "HandleSymbolDrawClick",
+  isStreaming: false,
+  inputSchema: import_connect90.HqServicesV1ComponentPlaceService.HandleSymbolDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.handleSymbolDrawClick(input);
+  }
+});
+registerSkill(HandleSymbolDrawClickSkill);
+
+// generated/placement/place-block.ts
+var import_connect91 = require("@hqedge/connect");
+var PlaceBlockSkill = defineSkill({
+  id: "placement-place-block",
+  title: "Place Block",
+  description: "block",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "PlaceBlock",
+  isStreaming: false,
+  inputSchema: import_connect91.HqServicesV1ObjPlaceService.BoxPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.placeBlock(input);
+  }
+});
+registerSkill(PlaceBlockSkill);
+
+// generated/placement/place-part.ts
+var import_connect92 = require("@hqedge/connect");
+var PlacePartSkill = defineSkill({
+  id: "placement-place-part",
+  title: "Place Part",
+  description: "part",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "PlacePart",
+  isStreaming: false,
+  inputSchema: import_connect92.HqServicesV1ComponentPlaceService.PlacePartRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.placePart(input);
+  }
+});
+registerSkill(PlacePartSkill);
+
+// generated/placement/place-symbol.ts
+var import_connect93 = require("@hqedge/connect");
+var PlaceSymbolSkill = defineSkill({
+  id: "placement-place-symbol",
+  title: "Place Symbol",
+  description: "symbol",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "PlaceSymbol",
+  isStreaming: false,
+  inputSchema: import_connect93.HqServicesV1ComponentPlaceService.PlaceSymbolRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.placeSymbol(input);
+  }
+});
+registerSkill(PlaceSymbolSkill);
+
+// generated/placement/set-net-alias-attach-obj.ts
+var import_connect94 = require("@hqedge/connect");
+var SetNetAliasAttachObjSkill = defineSkill({
+  id: "placement-set-net-alias-attach-obj",
+  title: "Set Net Alias Attach Obj",
+  description: "net alias attach",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "SetNetAliasAttachObj",
+  isStreaming: false,
+  inputSchema: import_connect94.HqServicesV1ComponentPlaceService.SetNetAliasAttachObjRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.setNetAliasAttachObj(input);
+  }
+});
+registerSkill(SetNetAliasAttachObjSkill);
+
+// generated/project/close-project.ts
+var import_connect95 = require("@hqedge/connect");
+var CloseProjectSkill = defineSkill({
+  id: "project-close-project",
+  title: "Close Project",
+  description: "Closes an opened project.",
+  domain: "project",
+  service: "ProjectService",
+  method: "CloseProject",
+  isStreaming: false,
+  inputSchema: import_connect95.HqServicesV1ProjectService.CloseProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.closeProject(input);
+  }
+});
+registerSkill(CloseProjectSkill);
+
+// generated/project/get-active-project.ts
+var import_connect96 = require("@hqedge/connect");
+var GetActiveProjectSkill = defineSkill({
+  id: "project-get-active-project",
+  title: "Get Active Project",
+  description: "Returns the project currently active in the editor UI.",
+  domain: "project",
+  service: "ProjectService",
+  method: "GetActiveProject",
+  isStreaming: false,
+  inputSchema: import_connect96.HqServicesV1ProjectService.GetActiveProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.getActiveProject(input);
+  }
+});
+registerSkill(GetActiveProjectSkill);
+
+// generated/project/get-project.ts
+var import_connect97 = require("@hqedge/connect");
+var GetProjectSkill = defineSkill({
+  id: "project-get-project",
+  title: "Get Project",
+  description: "Returns one opened project.",
+  domain: "project",
+  service: "ProjectService",
+  method: "GetProject",
+  isStreaming: false,
+  inputSchema: import_connect97.HqServicesV1ProjectService.GetProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.getProject(input);
+  }
+});
+registerSkill(GetProjectSkill);
+
+// generated/project/list-open-projects.ts
+var import_connect98 = require("@hqedge/connect");
+var ListOpenProjectsSkill = defineSkill({
+  id: "project-list-open-projects",
+  title: "List Open Projects",
+  description: "Returns all projects currently opened in this HQ EDA process.",
+  domain: "project",
+  service: "ProjectService",
+  method: "ListOpenProjects",
+  isStreaming: false,
+  inputSchema: import_connect98.HqServicesV1ProjectService.ListOpenProjectsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.listOpenProjects(input);
+  }
+});
+registerSkill(ListOpenProjectsSkill);
+
+// generated/project/open-project.ts
+var import_connect99 = require("@hqedge/connect");
+var OpenProjectSkill = defineSkill({
+  id: "project-open-project",
+  title: "Open Project",
+  description: "Opens a project into the current HQ EDA editor process.",
+  domain: "project",
+  service: "ProjectService",
+  method: "OpenProject",
+  isStreaming: false,
+  inputSchema: import_connect99.HqServicesV1ProjectService.OpenProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.openProject(input);
+  }
+});
+registerSkill(OpenProjectSkill);
+
+// generated/project/save-project.ts
+var import_connect100 = require("@hqedge/connect");
+var SaveProjectSkill = defineSkill({
+  id: "project-save-project",
+  title: "Save Project",
+  description: "Persists an opened project.",
+  domain: "project",
+  service: "ProjectService",
+  method: "SaveProject",
+  isStreaming: false,
+  inputSchema: import_connect100.HqServicesV1ProjectService.SaveProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.saveProject(input);
+  }
+});
+registerSkill(SaveProjectSkill);
+
+// generated/runtime/execute-commands.ts
+var import_connect101 = require("@hqedge/connect");
+var ExecuteCommandsSkill = defineSkill({
+  id: "runtime-execute-commands",
+  title: "Execute Commands",
+  description: "Execute Commands via RuntimeService.ExecuteCommands",
+  domain: "runtime",
+  service: "RuntimeService",
+  method: "ExecuteCommands",
+  isStreaming: false,
+  inputSchema: import_connect101.HqRuntimeV1Command.ExecuteCommandsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.runtime.executeCommands(input);
+  }
+});
+registerSkill(ExecuteCommandsSkill);
+
+// generated/runtime/validate-commands.ts
+var import_connect102 = require("@hqedge/connect");
+var ValidateCommandsSkill = defineSkill({
+  id: "runtime-validate-commands",
+  title: "Validate Commands",
+  description: "Validate Commands via RuntimeService.ValidateCommands",
+  domain: "runtime",
+  service: "RuntimeService",
+  method: "ValidateCommands",
+  isStreaming: false,
+  inputSchema: import_connect102.HqRuntimeV1Validator.ValidationRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.runtime.validateCommands(input);
+  }
+});
+registerSkill(ValidateCommandsSkill);
+
+// generated/selection/clear-selection.ts
+var import_connect103 = require("@hqedge/connect");
+var ClearSelectionSkill = defineSkill({
+  id: "selection-clear-selection",
+  title: "Clear Selection",
+  description: "Clear Selection via SelectionService.ClearSelection",
+  domain: "selection",
+  service: "SelectionService",
+  method: "ClearSelection",
+  isStreaming: false,
+  inputSchema: import_connect103.HqServicesV1SelectionService.ClearSelectionRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.selection.clearSelection(input);
+  }
+});
+registerSkill(ClearSelectionSkill);
+
+// generated/selection/get-selection.ts
+var import_connect104 = require("@hqedge/connect");
+var GetSelectionSkill = defineSkill({
+  id: "selection-get-selection",
+  title: "Get Selection",
+  description: "Get Selection via SelectionService.GetSelection",
+  domain: "selection",
+  service: "SelectionService",
+  method: "GetSelection",
+  isStreaming: false,
+  inputSchema: import_connect104.HqServicesV1SelectionService.GetSelectionRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.selection.getSelection(input);
+  }
+});
+registerSkill(GetSelectionSkill);
+
+// generated/selection/set-selection.ts
+var import_connect105 = require("@hqedge/connect");
+var SetSelectionSkill = defineSkill({
+  id: "selection-set-selection",
+  title: "Set Selection",
+  description: "Set Selection via SelectionService.SetSelection",
+  domain: "selection",
+  service: "SelectionService",
+  method: "SetSelection",
+  isStreaming: false,
+  inputSchema: import_connect105.HqServicesV1SelectionService.SetSelectionRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.selection.setSelection(input);
+  }
+});
+registerSkill(SetSelectionSkill);
+
+// generated/transaction/commit.ts
+var import_connect106 = require("@hqedge/connect");
+var CommitSkill = defineSkill({
+  id: "transaction-commit",
+  title: "Commit",
+  description: "Commit via TransactionService.Commit",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Commit",
+  isStreaming: false,
+  inputSchema: import_connect106.HqRuntimeV1Transaction.TransactionCommitRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.commit(input);
+  }
+});
+registerSkill(CommitSkill);
+
+// generated/transaction/open.ts
+var import_connect107 = require("@hqedge/connect");
+var OpenSkill = defineSkill({
+  id: "transaction-open",
+  title: "Open",
+  description: "Open via TransactionService.Open",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Open",
+  isStreaming: false,
+  inputSchema: import_connect107.HqRuntimeV1Transaction.TransactionOpenRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.open(input);
+  }
+});
+registerSkill(OpenSkill);
+
+// generated/transaction/redo.ts
+var import_connect108 = require("@hqedge/connect");
+var RedoSkill = defineSkill({
+  id: "transaction-redo",
+  title: "Redo",
+  description: "Redo via TransactionService.Redo",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Redo",
+  isStreaming: false,
+  inputSchema: import_connect108.HqRuntimeV1Undo.RedoRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.redo(input);
+  }
+});
+registerSkill(RedoSkill);
+
+// generated/transaction/rollback.ts
+var import_connect109 = require("@hqedge/connect");
+var RollbackSkill = defineSkill({
+  id: "transaction-rollback",
+  title: "Rollback",
+  description: "Rollback via TransactionService.Rollback",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Rollback",
+  isStreaming: false,
+  inputSchema: import_connect109.HqRuntimeV1Transaction.TransactionDiscardRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.rollback(input);
+  }
+});
+registerSkill(RollbackSkill);
+
+// generated/transaction/undo.ts
+var import_connect110 = require("@hqedge/connect");
+var UndoSkill = defineSkill({
+  id: "transaction-undo",
+  title: "Undo",
+  description: "Undo via TransactionService.Undo",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Undo",
+  isStreaming: false,
+  inputSchema: import_connect110.HqRuntimeV1Undo.UndoRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.undo(input);
+  }
+});
+registerSkill(UndoSkill);
+
+// generated/index.ts
+var SKILLS = {
+  "ai-execute-prompt": ExecutePromptSkill,
+  "bom-get-bom": GetBomSkill,
+  "canvas-align-objects": AlignObjectsSkill,
+  "canvas-can-paste": CanPasteSkill,
+  "canvas-clear-all-sel": ClearAllSelSkill,
+  "canvas-copy-selected": CopySelectedSkill,
+  "canvas-delete-selected": DeleteSelectedSkill,
+  "canvas-distribute-objects": DistributeObjectsSkill,
+  "canvas-get-align-type": GetAlignTypeSkill,
+  "canvas-get-selected-object-json": GetSelectedObjectJsonSkill,
+  "canvas-get-selected-objects-json": GetSelectedObjectsJsonSkill,
+  "canvas-mirror-objects": MirrorObjectsSkill,
+  "canvas-move-selected-objs": MoveSelectedObjsSkill,
+  "canvas-on-canvas-escape": OnCanvasEscapeSkill,
+  "canvas-pan-canvas": PanCanvasSkill,
+  "canvas-paste-selected": PasteSelectedSkill,
+  "canvas-rotate-objects": RotateObjectsSkill,
+  "canvas-screen-to-canvas-local": ScreenToCanvasLocalSkill,
+  "canvas-select-all": SelectAllSkill,
+  "canvas-select-object-at": SelectObjectAtSkill,
+  "canvas-set-align-type": SetAlignTypeSkill,
+  "canvas-set-page-size": SetPageSizeSkill,
+  "canvas-set-page-size-rect": SetPageSizeRectSkill,
+  "canvas-zoom-all": ZoomAllSkill,
+  "canvas-zoom-area-by-double-box": ZoomAreaByDoubleBoxSkill,
+  "canvas-zoom-area-by-int-box": ZoomAreaByIntBoxSkill,
+  "canvas-zoom-area-by-points": ZoomAreaByPointsSkill,
+  "canvas-zoom-in": ZoomInSkill,
+  "canvas-zoom-out": ZoomOutSkill,
+  "canvas-zoom-selected": ZoomSelectedSkill,
+  "capability-get-capabilities": GetCapabilitiesSkill,
+  "context-get-context": GetContextSkill,
+  "discovery-get-server-info": GetServerInfoSkill,
+  "erc-clear-all-findings": ClearAllFindingsSkill,
+  "erc-clear-findings": ClearFindingsSkill,
+  "erc-run-checks": RunChecksSkill,
+  "erc-set-erc-report-webview-visibility": SetErcReportWebviewVisibilitySkill,
+  "erc-set-report-webview-state": SetReportWebviewStateSkill,
+  "erc-show-findings": ShowFindingsSkill,
+  "event-subscribe": SubscribeSkill,
+  "export-export-bom": ExportBOMSkill,
+  "export-export-target": ExportTargetSkill,
+  "graph-get-connectivity": GetConnectivitySkill,
+  "graph-query-graph": QueryGraphSkill,
+  "import-import-design": ImportDesignSkill,
+  "kernel-get-entity": GetEntitySkill,
+  "kernel-get-snapshot": GetSnapshotSkill,
+  "obj-place-add-bus-segment": AddBusSegmentSkill,
+  "obj-place-add-ellipse": AddEllipseSkill,
+  "obj-place-add-free-line-segment": AddFreeLineSegmentSkill,
+  "obj-place-add-line": AddLineSkill,
+  "obj-place-add-rect": AddRectSkill,
+  "obj-place-add-wire-segment": AddWireSegmentSkill,
+  "obj-place-cancel-bus-draw": CancelBusDrawSkill,
+  "obj-place-cancel-ellipse-arc-draw": CancelEllipseArcDrawSkill,
+  "obj-place-cancel-ellipse-draw": CancelEllipseDrawSkill,
+  "obj-place-cancel-free-line-draw": CancelFreeLineDrawSkill,
+  "obj-place-cancel-line-draw": CancelLineDrawSkill,
+  "obj-place-cancel-rect-draw": CancelRectDrawSkill,
+  "obj-place-cancel-wire-draw": CancelWireDrawSkill,
+  "obj-place-handle-bus-draw-click": HandleBusDrawClickSkill,
+  "obj-place-handle-ellipse-arc-draw-click": HandleEllipseArcDrawClickSkill,
+  "obj-place-handle-ellipse-draw-click": HandleEllipseDrawClickSkill,
+  "obj-place-handle-free-line-draw-click": HandleFreeLineDrawClickSkill,
+  "obj-place-handle-image-draw-click": HandleImageDrawClickSkill,
+  "obj-place-handle-line-draw-click": HandleLineDrawClickSkill,
+  "obj-place-handle-net-alias-draw-click": HandleNetAliasDrawClickSkill,
+  "obj-place-handle-rect-draw-click": HandleRectDrawClickSkill,
+  "obj-place-handle-table-draw-click": HandleTableDrawClickSkill,
+  "obj-place-handle-text-draw-click": HandleTextDrawClickSkill,
+  "obj-place-handle-wire-draw-click": HandleWireDrawClickSkill,
+  "obj-place-place-bus": PlaceBusSkill,
+  "obj-place-place-ellipse": PlaceEllipseSkill,
+  "obj-place-place-ellipse-arc": PlaceEllipseArcSkill,
+  "obj-place-place-ellipse-arc-from-virtual": PlaceEllipseArcFromVirtualSkill,
+  "obj-place-place-free-line": PlaceFreeLineSkill,
+  "obj-place-place-image": PlaceImageSkill,
+  "obj-place-place-line": PlaceLineSkill,
+  "obj-place-place-net-alias": PlaceNetAliasSkill,
+  "obj-place-place-rect": PlaceRectSkill,
+  "obj-place-place-table": PlaceTableSkill,
+  "obj-place-place-table-from-virtual": PlaceTableFromVirtualSkill,
+  "obj-place-place-text": PlaceTextSkill,
+  "obj-place-place-text-from-virtual": PlaceTextFromVirtualSkill,
+  "obj-place-place-wire": PlaceWireSkill,
+  "placement-cancel-block-draw": CancelBlockDrawSkill,
+  "placement-clear-net-alias-attach-obj": ClearNetAliasAttachObjSkill,
+  "placement-handle-block-draw-click": HandleBlockDrawClickSkill,
+  "placement-handle-part-draw-click": HandlePartDrawClickSkill,
+  "placement-handle-symbol-draw-click": HandleSymbolDrawClickSkill,
+  "placement-place-block": PlaceBlockSkill,
+  "placement-place-part": PlacePartSkill,
+  "placement-place-symbol": PlaceSymbolSkill,
+  "placement-set-net-alias-attach-obj": SetNetAliasAttachObjSkill,
+  "project-close-project": CloseProjectSkill,
+  "project-get-active-project": GetActiveProjectSkill,
+  "project-get-project": GetProjectSkill,
+  "project-list-open-projects": ListOpenProjectsSkill,
+  "project-open-project": OpenProjectSkill,
+  "project-save-project": SaveProjectSkill,
+  "runtime-execute-commands": ExecuteCommandsSkill,
+  "runtime-validate-commands": ValidateCommandsSkill,
+  "selection-clear-selection": ClearSelectionSkill,
+  "selection-get-selection": GetSelectionSkill,
+  "selection-set-selection": SetSelectionSkill,
+  "transaction-commit": CommitSkill,
+  "transaction-open": OpenSkill,
+  "transaction-redo": RedoSkill,
+  "transaction-rollback": RollbackSkill,
+  "transaction-undo": UndoSkill
+};
+function listSkills() {
+  return Object.values(SKILLS).sort((a, b) => a.id.localeCompare(b.id));
+}
+function getSkill(id) {
+  return SKILLS[id];
+}
+
+// src/index.ts
+var import_huaqiu_client = require("@huaqiu/huaqiu-client");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SKILLS,
+  getSkill,
+  listSkills,
+  toJson,
+  toJsonString
+});
+//# sourceMappingURL=index.cjs.map