@huaqiu/hqeda 0.1.1

package/dist/index.js

@@ -0,0 +1,2008 @@
+// 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
+import { HqServicesV1AiService } from "@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: HqServicesV1AiService.AIRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.ai.executePrompt(input);
+  }
+});
+registerSkill(ExecutePromptSkill);
+
+// generated/bom/get-bom.ts
+import { HqFabV1GetEdaBom } from "@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: HqFabV1GetEdaBom.GetBomRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.edaBom.getBom(input);
+  }
+});
+registerSkill(GetBomSkill);
+
+// generated/canvas/align-objects.ts
+import { HqServicesV1CanvasOpsService } from "@hqedge/connect";
+var AlignObjectsSkill = defineSkill({
+  id: "canvas-align-objects",
+  title: "Align Objects",
+  description: "transform",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "AlignObjects",
+  isStreaming: false,
+  inputSchema: HqServicesV1CanvasOpsService.AlignModeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.alignObjects(input);
+  }
+});
+registerSkill(AlignObjectsSkill);
+
+// generated/canvas/can-paste.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService2 } from "@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: HqServicesV1CanvasOpsService2.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.canPaste(input);
+  }
+});
+registerSkill(CanPasteSkill);
+
+// generated/canvas/clear-all-sel.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService3 } from "@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: HqServicesV1CanvasOpsService3.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.clearAllSel(input);
+  }
+});
+registerSkill(ClearAllSelSkill);
+
+// generated/canvas/copy-selected.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService4 } from "@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: HqServicesV1CanvasOpsService4.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.copySelected(input);
+  }
+});
+registerSkill(CopySelectedSkill);
+
+// generated/canvas/delete-selected.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService5 } from "@hqedge/connect";
+var DeleteSelectedSkill = defineSkill({
+  id: "canvas-delete-selected",
+  title: "Delete Selected",
+  description: "edit",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "DeleteSelected",
+  isStreaming: false,
+  inputSchema: HqServicesV1CanvasOpsService5.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.deleteSelected(input);
+  }
+});
+registerSkill(DeleteSelectedSkill);
+
+// generated/canvas/distribute-objects.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService6 } from "@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: HqServicesV1CanvasOpsService6.AlignModeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.distributeObjects(input);
+  }
+});
+registerSkill(DistributeObjectsSkill);
+
+// generated/canvas/get-align-type.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService7 } from "@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: HqServicesV1CanvasOpsService7.GetAlignTypeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.getAlignType(input);
+  }
+});
+registerSkill(GetAlignTypeSkill);
+
+// generated/canvas/get-selected-object-json.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService8 } from "@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: HqServicesV1CanvasOpsService8.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.getSelectedObjectJson(input);
+  }
+});
+registerSkill(GetSelectedObjectJsonSkill);
+
+// generated/canvas/get-selected-objects-json.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService9 } from "@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: HqServicesV1CanvasOpsService9.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.getSelectedObjectsJson(input);
+  }
+});
+registerSkill(GetSelectedObjectsJsonSkill);
+
+// generated/canvas/mirror-objects.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService10 } from "@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: HqServicesV1CanvasOpsService10.AlignModeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.mirrorObjects(input);
+  }
+});
+registerSkill(MirrorObjectsSkill);
+
+// generated/canvas/move-selected-objs.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService11 } from "@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: HqServicesV1CanvasOpsService11.MoveSelectedObjsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.moveSelectedObjs(input);
+  }
+});
+registerSkill(MoveSelectedObjsSkill);
+
+// generated/canvas/on-canvas-escape.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService12 } from "@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: HqServicesV1CanvasOpsService12.OnCanvasEscapeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.onCanvasEscape(input);
+  }
+});
+registerSkill(OnCanvasEscapeSkill);
+
+// generated/canvas/pan-canvas.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService13 } from "@hqedge/connect";
+var PanCanvasSkill = defineSkill({
+  id: "canvas-pan-canvas",
+  title: "Pan Canvas",
+  description: "viewport",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "PanCanvas",
+  isStreaming: false,
+  inputSchema: HqServicesV1CanvasOpsService13.PanCanvasRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.panCanvas(input);
+  }
+});
+registerSkill(PanCanvasSkill);
+
+// generated/canvas/paste-selected.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService14 } from "@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: HqServicesV1CanvasOpsService14.PasteRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.pasteSelected(input);
+  }
+});
+registerSkill(PasteSelectedSkill);
+
+// generated/canvas/rotate-objects.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService15 } from "@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: HqServicesV1CanvasOpsService15.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.rotateObjects(input);
+  }
+});
+registerSkill(RotateObjectsSkill);
+
+// generated/canvas/screen-to-canvas-local.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService16 } from "@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: HqServicesV1CanvasOpsService16.ScreenToCanvasLocalRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.screenToCanvasLocal(input);
+  }
+});
+registerSkill(ScreenToCanvasLocalSkill);
+
+// generated/canvas/select-all.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService17 } from "@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: HqServicesV1CanvasOpsService17.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.selectAll(input);
+  }
+});
+registerSkill(SelectAllSkill);
+
+// generated/canvas/select-object-at.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService18 } from "@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: HqServicesV1CanvasOpsService18.WindowClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.selectObjectAt(input);
+  }
+});
+registerSkill(SelectObjectAtSkill);
+
+// generated/canvas/set-align-type.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService19 } from "@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: HqServicesV1CanvasOpsService19.SetAlignTypeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.setAlignType(input);
+  }
+});
+registerSkill(SetAlignTypeSkill);
+
+// generated/canvas/set-page-size.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService20 } from "@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: HqServicesV1CanvasOpsService20.SetPageSizeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.setPageSize(input);
+  }
+});
+registerSkill(SetPageSizeSkill);
+
+// generated/canvas/set-page-size-rect.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService21 } from "@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: HqServicesV1CanvasOpsService21.SetPageSizeRectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.setPageSizeRect(input);
+  }
+});
+registerSkill(SetPageSizeRectSkill);
+
+// generated/canvas/zoom-all.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService22 } from "@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: HqServicesV1CanvasOpsService22.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAll(input);
+  }
+});
+registerSkill(ZoomAllSkill);
+
+// generated/canvas/zoom-area-by-double-box.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService23 } from "@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: HqServicesV1CanvasOpsService23.ZoomAreaDoubleBoxRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAreaByDoubleBox(input);
+  }
+});
+registerSkill(ZoomAreaByDoubleBoxSkill);
+
+// generated/canvas/zoom-area-by-int-box.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService24 } from "@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: HqServicesV1CanvasOpsService24.ZoomAreaIntBoxRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAreaByIntBox(input);
+  }
+});
+registerSkill(ZoomAreaByIntBoxSkill);
+
+// generated/canvas/zoom-area-by-points.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService25 } from "@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: HqServicesV1CanvasOpsService25.ZoomAreaPointsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomAreaByPoints(input);
+  }
+});
+registerSkill(ZoomAreaByPointsSkill);
+
+// generated/canvas/zoom-in.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService26 } from "@hqedge/connect";
+var ZoomInSkill = defineSkill({
+  id: "canvas-zoom-in",
+  title: "Zoom In",
+  description: "zoom",
+  domain: "canvas",
+  service: "CanvasOpsService",
+  method: "ZoomIn",
+  isStreaming: false,
+  inputSchema: HqServicesV1CanvasOpsService26.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomIn(input);
+  }
+});
+registerSkill(ZoomInSkill);
+
+// generated/canvas/zoom-out.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService27 } from "@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: HqServicesV1CanvasOpsService27.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomOut(input);
+  }
+});
+registerSkill(ZoomOutSkill);
+
+// generated/canvas/zoom-selected.ts
+import { HqServicesV1CanvasOpsService as HqServicesV1CanvasOpsService28 } from "@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: HqServicesV1CanvasOpsService28.CanvasContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.canvasOps.zoomSelected(input);
+  }
+});
+registerSkill(ZoomSelectedSkill);
+
+// generated/capability/get-capabilities.ts
+import { HqServicesV1CapabilityService } from "@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: HqServicesV1CapabilityService.GetCapabilitiesRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.capability.getCapabilities(input);
+  }
+});
+registerSkill(GetCapabilitiesSkill);
+
+// generated/context/get-context.ts
+import { HqServicesV1ContextService } from "@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: HqServicesV1ContextService.GetContextRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.context.getContext(input);
+  }
+});
+registerSkill(GetContextSkill);
+
+// generated/discovery/get-server-info.ts
+import { HqDiscoveryV1Discovery } from "@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: HqDiscoveryV1Discovery.GetServerInfoRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.discovery.getServerInfo(input);
+  }
+});
+registerSkill(GetServerInfoSkill);
+
+// generated/erc/clear-all-findings.ts
+import { HqServicesV1ErcService } from "@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: HqServicesV1ErcService.ClearAllFindingsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.clearAllFindings(input);
+  }
+});
+registerSkill(ClearAllFindingsSkill);
+
+// generated/erc/clear-findings.ts
+import { HqServicesV1ErcService as HqServicesV1ErcService2 } from "@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: HqServicesV1ErcService2.ClearFindingsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.clearFindings(input);
+  }
+});
+registerSkill(ClearFindingsSkill);
+
+// generated/erc/run-checks.ts
+import { HqServicesV1ErcService as HqServicesV1ErcService3 } from "@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: HqServicesV1ErcService3.RunChecksRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.runChecks(input);
+  }
+});
+registerSkill(RunChecksSkill);
+
+// generated/erc/set-erc-report-webview-visibility.ts
+import { HqServicesV1ErcService as HqServicesV1ErcService4 } from "@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: HqServicesV1ErcService4.SetErcReportWebviewVisibilityRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.setErcReportWebviewVisibility(input);
+  }
+});
+registerSkill(SetErcReportWebviewVisibilitySkill);
+
+// generated/erc/set-report-webview-state.ts
+import { HqServicesV1ErcService as HqServicesV1ErcService5 } from "@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: HqServicesV1ErcService5.SetReportWebviewStateRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.setReportWebviewState(input);
+  }
+});
+registerSkill(SetReportWebviewStateSkill);
+
+// generated/erc/show-findings.ts
+import { HqServicesV1ErcService as HqServicesV1ErcService6 } from "@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: HqServicesV1ErcService6.ShowFindingsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.erc.showFindings(input);
+  }
+});
+registerSkill(ShowFindingsSkill);
+
+// generated/event/subscribe.ts
+import { HqServicesV1EventService } from "@hqedge/connect";
+var SubscribeSkill = defineSkill({
+  id: "event-subscribe",
+  title: "Subscribe",
+  description: "Subscribe via EventService.Subscribe",
+  domain: "event",
+  service: "EventService",
+  method: "Subscribe",
+  isStreaming: true,
+  inputSchema: HqServicesV1EventService.SubscribeRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.event.subscribe(input);
+  }
+});
+registerSkill(SubscribeSkill);
+
+// generated/export/export-bom.ts
+import { HqServicesV1ExportService } from "@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: HqServicesV1ExportService.ExportBOMRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.export.exportBOM(input);
+  }
+});
+registerSkill(ExportBOMSkill);
+
+// generated/export/export-target.ts
+import { HqServicesV1ExportService as HqServicesV1ExportService2 } from "@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: HqServicesV1ExportService2.ExportTargetRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.export.exportTarget(input);
+  }
+});
+registerSkill(ExportTargetSkill);
+
+// generated/graph/get-connectivity.ts
+import { HqServicesV1GraphService } from "@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: HqServicesV1GraphService.ConnectivityRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.graph.getConnectivity(input);
+  }
+});
+registerSkill(GetConnectivitySkill);
+
+// generated/graph/query-graph.ts
+import { HqServicesV1GraphService as HqServicesV1GraphService2 } from "@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: HqServicesV1GraphService2.GraphQueryRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.graph.queryGraph(input);
+  }
+});
+registerSkill(QueryGraphSkill);
+
+// generated/import/import-design.ts
+import { HqServicesV1ImportService } from "@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: HqServicesV1ImportService.ImportDesignRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.import.importDesign(input);
+  }
+});
+registerSkill(ImportDesignSkill);
+
+// generated/kernel/get-entity.ts
+import { HqServicesV1KernelService } from "@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: HqServicesV1KernelService.GetEntityRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.kernel.getEntity(input);
+  }
+});
+registerSkill(GetEntitySkill);
+
+// generated/kernel/get-snapshot.ts
+import { HqServicesV1KernelService as HqServicesV1KernelService2 } from "@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: HqServicesV1KernelService2.GetSnapshotRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.kernel.getSnapshot(input);
+  }
+});
+registerSkill(GetSnapshotSkill);
+
+// generated/obj-place/add-bus-segment.ts
+import { HqServicesV1ObjPlaceService } from "@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: HqServicesV1ObjPlaceService.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addBusSegment(input);
+  }
+});
+registerSkill(AddBusSegmentSkill);
+
+// generated/obj-place/add-ellipse.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService2 } from "@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: HqServicesV1ObjPlaceService2.BoxShiftPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addEllipse(input);
+  }
+});
+registerSkill(AddEllipseSkill);
+
+// generated/obj-place/add-free-line-segment.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService3 } from "@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: HqServicesV1ObjPlaceService3.AddFreeLineSegmentRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addFreeLineSegment(input);
+  }
+});
+registerSkill(AddFreeLineSegmentSkill);
+
+// generated/obj-place/add-line.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService4 } from "@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: HqServicesV1ObjPlaceService4.AddLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addLine(input);
+  }
+});
+registerSkill(AddLineSkill);
+
+// generated/obj-place/add-rect.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService5 } from "@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: HqServicesV1ObjPlaceService5.BoxPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addRect(input);
+  }
+});
+registerSkill(AddRectSkill);
+
+// generated/obj-place/add-wire-segment.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService6 } from "@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: HqServicesV1ObjPlaceService6.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.addWireSegment(input);
+  }
+});
+registerSkill(AddWireSegmentSkill);
+
+// generated/obj-place/cancel-bus-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService7 } from "@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: HqServicesV1ObjPlaceService7.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelBusDraw(input);
+  }
+});
+registerSkill(CancelBusDrawSkill);
+
+// generated/obj-place/cancel-ellipse-arc-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService8 } from "@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: HqServicesV1ObjPlaceService8.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelEllipseArcDraw(input);
+  }
+});
+registerSkill(CancelEllipseArcDrawSkill);
+
+// generated/obj-place/cancel-ellipse-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService9 } from "@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: HqServicesV1ObjPlaceService9.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelEllipseDraw(input);
+  }
+});
+registerSkill(CancelEllipseDrawSkill);
+
+// generated/obj-place/cancel-free-line-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService10 } from "@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: HqServicesV1ObjPlaceService10.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelFreeLineDraw(input);
+  }
+});
+registerSkill(CancelFreeLineDrawSkill);
+
+// generated/obj-place/cancel-line-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService11 } from "@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: HqServicesV1ObjPlaceService11.CancelLineDrawRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelLineDraw(input);
+  }
+});
+registerSkill(CancelLineDrawSkill);
+
+// generated/obj-place/cancel-rect-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService12 } from "@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: HqServicesV1ObjPlaceService12.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelRectDraw(input);
+  }
+});
+registerSkill(CancelRectDrawSkill);
+
+// generated/obj-place/cancel-wire-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService13 } from "@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: HqServicesV1ObjPlaceService13.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.cancelWireDraw(input);
+  }
+});
+registerSkill(CancelWireDrawSkill);
+
+// generated/obj-place/handle-bus-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService14 } from "@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: HqServicesV1ObjPlaceService14.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleBusDrawClick(input);
+  }
+});
+registerSkill(HandleBusDrawClickSkill);
+
+// generated/obj-place/handle-ellipse-arc-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService15 } from "@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: HqServicesV1ObjPlaceService15.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleEllipseArcDrawClick(input);
+  }
+});
+registerSkill(HandleEllipseArcDrawClickSkill);
+
+// generated/obj-place/handle-ellipse-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService16 } from "@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: HqServicesV1ObjPlaceService16.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleEllipseDrawClick(input);
+  }
+});
+registerSkill(HandleEllipseDrawClickSkill);
+
+// generated/obj-place/handle-free-line-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService17 } from "@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: HqServicesV1ObjPlaceService17.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleFreeLineDrawClick(input);
+  }
+});
+registerSkill(HandleFreeLineDrawClickSkill);
+
+// generated/obj-place/handle-image-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService18 } from "@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: HqServicesV1ObjPlaceService18.HandleImageDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleImageDrawClick(input);
+  }
+});
+registerSkill(HandleImageDrawClickSkill);
+
+// generated/obj-place/handle-line-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService19 } from "@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: HqServicesV1ObjPlaceService19.HandleLineDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleLineDrawClick(input);
+  }
+});
+registerSkill(HandleLineDrawClickSkill);
+
+// generated/obj-place/handle-net-alias-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService20 } from "@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: HqServicesV1ObjPlaceService20.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleNetAliasDrawClick(input);
+  }
+});
+registerSkill(HandleNetAliasDrawClickSkill);
+
+// generated/obj-place/handle-rect-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService21 } from "@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: HqServicesV1ObjPlaceService21.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleRectDrawClick(input);
+  }
+});
+registerSkill(HandleRectDrawClickSkill);
+
+// generated/obj-place/handle-table-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService22 } from "@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: HqServicesV1ObjPlaceService22.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleTableDrawClick(input);
+  }
+});
+registerSkill(HandleTableDrawClickSkill);
+
+// generated/obj-place/handle-text-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService23 } from "@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: HqServicesV1ObjPlaceService23.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleTextDrawClick(input);
+  }
+});
+registerSkill(HandleTextDrawClickSkill);
+
+// generated/obj-place/handle-wire-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService24 } from "@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: HqServicesV1ObjPlaceService24.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.handleWireDrawClick(input);
+  }
+});
+registerSkill(HandleWireDrawClickSkill);
+
+// generated/obj-place/place-bus.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService25 } from "@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: HqServicesV1ObjPlaceService25.PlaceLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeBus(input);
+  }
+});
+registerSkill(PlaceBusSkill);
+
+// generated/obj-place/place-ellipse.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService26 } from "@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: HqServicesV1ObjPlaceService26.BoxShiftPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeEllipse(input);
+  }
+});
+registerSkill(PlaceEllipseSkill);
+
+// generated/obj-place/place-ellipse-arc.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService27 } from "@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: HqServicesV1ObjPlaceService27.ObjDataPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeEllipseArc(input);
+  }
+});
+registerSkill(PlaceEllipseArcSkill);
+
+// generated/obj-place/place-ellipse-arc-from-virtual.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService28 } from "@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: HqServicesV1ObjPlaceService28.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeEllipseArcFromVirtual(input);
+  }
+});
+registerSkill(PlaceEllipseArcFromVirtualSkill);
+
+// generated/obj-place/place-free-line.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService29 } from "@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: HqServicesV1ObjPlaceService29.PlaceFreeLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeFreeLine(input);
+  }
+});
+registerSkill(PlaceFreeLineSkill);
+
+// generated/obj-place/place-image.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService30 } from "@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: HqServicesV1ObjPlaceService30.PlaceImageRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeImage(input);
+  }
+});
+registerSkill(PlaceImageSkill);
+
+// generated/obj-place/place-line.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService31 } from "@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: HqServicesV1ObjPlaceService31.PlaceLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeLine(input);
+  }
+});
+registerSkill(PlaceLineSkill);
+
+// generated/obj-place/place-net-alias.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService32 } from "@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: HqServicesV1ObjPlaceService32.PlaceNetAliasRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeNetAlias(input);
+  }
+});
+registerSkill(PlaceNetAliasSkill);
+
+// generated/obj-place/place-rect.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService33 } from "@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: HqServicesV1ObjPlaceService33.BoxPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeRect(input);
+  }
+});
+registerSkill(PlaceRectSkill);
+
+// generated/obj-place/place-table.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService34 } from "@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: HqServicesV1ObjPlaceService34.ObjDataPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeTable(input);
+  }
+});
+registerSkill(PlaceTableSkill);
+
+// generated/obj-place/place-table-from-virtual.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService35 } from "@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: HqServicesV1ObjPlaceService35.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeTableFromVirtual(input);
+  }
+});
+registerSkill(PlaceTableFromVirtualSkill);
+
+// generated/obj-place/place-text.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService36 } from "@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: HqServicesV1ObjPlaceService36.ObjDataPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeText(input);
+  }
+});
+registerSkill(PlaceTextSkill);
+
+// generated/obj-place/place-text-from-virtual.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService37 } from "@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: HqServicesV1ObjPlaceService37.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeTextFromVirtual(input);
+  }
+});
+registerSkill(PlaceTextFromVirtualSkill);
+
+// generated/obj-place/place-wire.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService38 } from "@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: HqServicesV1ObjPlaceService38.PlaceLineRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.objPlace.placeWire(input);
+  }
+});
+registerSkill(PlaceWireSkill);
+
+// generated/placement/cancel-block-draw.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService39 } from "@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: HqServicesV1ObjPlaceService39.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.cancelBlockDraw(input);
+  }
+});
+registerSkill(CancelBlockDrawSkill);
+
+// generated/placement/clear-net-alias-attach-obj.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService40 } from "@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: HqServicesV1ObjPlaceService40.ContextOnlyRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.clearNetAliasAttachObj(input);
+  }
+});
+registerSkill(ClearNetAliasAttachObjSkill);
+
+// generated/placement/handle-block-draw-click.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService41 } from "@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: HqServicesV1ObjPlaceService41.LocalClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.handleBlockDrawClick(input);
+  }
+});
+registerSkill(HandleBlockDrawClickSkill);
+
+// generated/placement/handle-part-draw-click.ts
+import { HqServicesV1ComponentPlaceService } from "@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: HqServicesV1ComponentPlaceService.HandlePartDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.handlePartDrawClick(input);
+  }
+});
+registerSkill(HandlePartDrawClickSkill);
+
+// generated/placement/handle-symbol-draw-click.ts
+import { HqServicesV1ComponentPlaceService as HqServicesV1ComponentPlaceService2 } from "@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: HqServicesV1ComponentPlaceService2.HandleSymbolDrawClickRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.handleSymbolDrawClick(input);
+  }
+});
+registerSkill(HandleSymbolDrawClickSkill);
+
+// generated/placement/place-block.ts
+import { HqServicesV1ObjPlaceService as HqServicesV1ObjPlaceService42 } from "@hqedge/connect";
+var PlaceBlockSkill = defineSkill({
+  id: "placement-place-block",
+  title: "Place Block",
+  description: "block",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "PlaceBlock",
+  isStreaming: false,
+  inputSchema: HqServicesV1ObjPlaceService42.BoxPlaceRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.placeBlock(input);
+  }
+});
+registerSkill(PlaceBlockSkill);
+
+// generated/placement/place-part.ts
+import { HqServicesV1ComponentPlaceService as HqServicesV1ComponentPlaceService3 } from "@hqedge/connect";
+var PlacePartSkill = defineSkill({
+  id: "placement-place-part",
+  title: "Place Part",
+  description: "part",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "PlacePart",
+  isStreaming: false,
+  inputSchema: HqServicesV1ComponentPlaceService3.PlacePartRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.placePart(input);
+  }
+});
+registerSkill(PlacePartSkill);
+
+// generated/placement/place-symbol.ts
+import { HqServicesV1ComponentPlaceService as HqServicesV1ComponentPlaceService4 } from "@hqedge/connect";
+var PlaceSymbolSkill = defineSkill({
+  id: "placement-place-symbol",
+  title: "Place Symbol",
+  description: "symbol",
+  domain: "placement",
+  service: "ComponentPlaceService",
+  method: "PlaceSymbol",
+  isStreaming: false,
+  inputSchema: HqServicesV1ComponentPlaceService4.PlaceSymbolRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.placeSymbol(input);
+  }
+});
+registerSkill(PlaceSymbolSkill);
+
+// generated/placement/set-net-alias-attach-obj.ts
+import { HqServicesV1ComponentPlaceService as HqServicesV1ComponentPlaceService5 } from "@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: HqServicesV1ComponentPlaceService5.SetNetAliasAttachObjRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.componentPlace.setNetAliasAttachObj(input);
+  }
+});
+registerSkill(SetNetAliasAttachObjSkill);
+
+// generated/project/close-project.ts
+import { HqServicesV1ProjectService } from "@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: HqServicesV1ProjectService.CloseProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.closeProject(input);
+  }
+});
+registerSkill(CloseProjectSkill);
+
+// generated/project/get-active-project.ts
+import { HqServicesV1ProjectService as HqServicesV1ProjectService2 } from "@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: HqServicesV1ProjectService2.GetActiveProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.getActiveProject(input);
+  }
+});
+registerSkill(GetActiveProjectSkill);
+
+// generated/project/get-project.ts
+import { HqServicesV1ProjectService as HqServicesV1ProjectService3 } from "@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: HqServicesV1ProjectService3.GetProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.getProject(input);
+  }
+});
+registerSkill(GetProjectSkill);
+
+// generated/project/list-open-projects.ts
+import { HqServicesV1ProjectService as HqServicesV1ProjectService4 } from "@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: HqServicesV1ProjectService4.ListOpenProjectsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.listOpenProjects(input);
+  }
+});
+registerSkill(ListOpenProjectsSkill);
+
+// generated/project/open-project.ts
+import { HqServicesV1ProjectService as HqServicesV1ProjectService5 } from "@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: HqServicesV1ProjectService5.OpenProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.openProject(input);
+  }
+});
+registerSkill(OpenProjectSkill);
+
+// generated/project/save-project.ts
+import { HqServicesV1ProjectService as HqServicesV1ProjectService6 } from "@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: HqServicesV1ProjectService6.SaveProjectRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.project.saveProject(input);
+  }
+});
+registerSkill(SaveProjectSkill);
+
+// generated/runtime/execute-commands.ts
+import { HqRuntimeV1Command } from "@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: HqRuntimeV1Command.ExecuteCommandsRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.runtime.executeCommands(input);
+  }
+});
+registerSkill(ExecuteCommandsSkill);
+
+// generated/runtime/validate-commands.ts
+import { HqRuntimeV1Validator } from "@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: HqRuntimeV1Validator.ValidationRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.runtime.validateCommands(input);
+  }
+});
+registerSkill(ValidateCommandsSkill);
+
+// generated/selection/clear-selection.ts
+import { HqServicesV1SelectionService } from "@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: HqServicesV1SelectionService.ClearSelectionRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.selection.clearSelection(input);
+  }
+});
+registerSkill(ClearSelectionSkill);
+
+// generated/selection/get-selection.ts
+import { HqServicesV1SelectionService as HqServicesV1SelectionService2 } from "@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: HqServicesV1SelectionService2.GetSelectionRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.selection.getSelection(input);
+  }
+});
+registerSkill(GetSelectionSkill);
+
+// generated/selection/set-selection.ts
+import { HqServicesV1SelectionService as HqServicesV1SelectionService3 } from "@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: HqServicesV1SelectionService3.SetSelectionRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.selection.setSelection(input);
+  }
+});
+registerSkill(SetSelectionSkill);
+
+// generated/transaction/commit.ts
+import { HqRuntimeV1Transaction } from "@hqedge/connect";
+var CommitSkill = defineSkill({
+  id: "transaction-commit",
+  title: "Commit",
+  description: "Commit via TransactionService.Commit",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Commit",
+  isStreaming: false,
+  inputSchema: HqRuntimeV1Transaction.TransactionCommitRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.commit(input);
+  }
+});
+registerSkill(CommitSkill);
+
+// generated/transaction/open.ts
+import { HqRuntimeV1Transaction as HqRuntimeV1Transaction2 } from "@hqedge/connect";
+var OpenSkill = defineSkill({
+  id: "transaction-open",
+  title: "Open",
+  description: "Open via TransactionService.Open",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Open",
+  isStreaming: false,
+  inputSchema: HqRuntimeV1Transaction2.TransactionOpenRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.open(input);
+  }
+});
+registerSkill(OpenSkill);
+
+// generated/transaction/redo.ts
+import { HqRuntimeV1Undo } from "@hqedge/connect";
+var RedoSkill = defineSkill({
+  id: "transaction-redo",
+  title: "Redo",
+  description: "Redo via TransactionService.Redo",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Redo",
+  isStreaming: false,
+  inputSchema: HqRuntimeV1Undo.RedoRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.redo(input);
+  }
+});
+registerSkill(RedoSkill);
+
+// generated/transaction/rollback.ts
+import { HqRuntimeV1Transaction as HqRuntimeV1Transaction3 } from "@hqedge/connect";
+var RollbackSkill = defineSkill({
+  id: "transaction-rollback",
+  title: "Rollback",
+  description: "Rollback via TransactionService.Rollback",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Rollback",
+  isStreaming: false,
+  inputSchema: HqRuntimeV1Transaction3.TransactionDiscardRequestSchema,
+  async execute(ctx, input) {
+    return await ctx.client.transaction.rollback(input);
+  }
+});
+registerSkill(RollbackSkill);
+
+// generated/transaction/undo.ts
+import { HqRuntimeV1Undo as HqRuntimeV1Undo2 } from "@hqedge/connect";
+var UndoSkill = defineSkill({
+  id: "transaction-undo",
+  title: "Undo",
+  description: "Undo via TransactionService.Undo",
+  domain: "transaction",
+  service: "TransactionService",
+  method: "Undo",
+  isStreaming: false,
+  inputSchema: HqRuntimeV1Undo2.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];
+}
+export {
+  SKILLS,
+  getSkill,
+  listSkills
+};
+//# sourceMappingURL=index.js.map