@longzai-intelligence-knowledge-graph/sdk 0.0.0-stage → 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,4515 @@
+import * as z from "zod";
+//#region src/shared/errors.d.ts
+/**
+ * 契约校验部位
+ */
+type ApiContractPart = 'params' | 'query' | 'body' | 'response';
+/**
+ * 契约校验错误详情
+ */
+type ApiContractErrorDetails = {
+  /**
+   * 端点标识，形如 graph.createGraph
+   */
+  readonly endpoint: string;
+  /**
+   * 校验失败的部位
+   */
+  readonly part: ApiContractPart;
+  /**
+   * 原始 zod 校验错误
+   */
+  readonly cause: z.ZodError;
+};
+/**
+ * 契约校验错误：端点入参或响应不符合生成契约时抛出
+ */
+declare class ApiContractError extends Error {
+  /**
+   * 端点标识，形如 graph.createGraph
+   */
+  readonly endpoint: string;
+  /**
+   * 校验失败的部位
+   */
+  readonly part: ApiContractPart;
+  /**
+   * 原始 zod 校验错误
+   */
+  readonly cause: z.ZodError;
+  /**
+   * 构造契约校验错误实例
+   *
+   * @param details - 错误详情
+   */
+  constructor(details: ApiContractErrorDetails);
+}
+//#endregion
+//#region src/shared/transport.types.d.ts
+/**
+ * 本文件由手工终态对齐生成形态维护，定义真源为产品仓 define 定义中心。
+ * 定义真源：产品仓 define 定义中心（见 `lzi-api.config.ts` definitions 入口）。
+ * 重新生成：`bun run api:generate`；一致性校验：`bun run api:check`。
+ */
+/**
+ * 生成包的最小传输契约：产品仓以 transport http-core 客户端或任意满足
+ * 结构约定的实现注入；生成包自身仅依赖 zod，不依赖任何定义侧模块
+ */
+/**
+ * HTTP 方法字面量联合，端点契约使用
+ */
+type ApiHttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/**
+ * 传输请求描述，端点函数组装后交给传输实现
+ */
+type ApiTransportRequest = {
+  /**
+   * HTTP 方法
+   */
+  readonly method: ApiHttpMethod;
+  /**
+   * 完整路径，路径参数已代入并编码
+   */
+  readonly path: string;
+  /**
+   * 查询参数，已通过 schema 校验
+   */
+  readonly query?: unknown;
+  /**
+   * 请求体，已通过 schema 校验
+   */
+  readonly body?: unknown;
+};
+/**
+ * 传输接口，由产品仓注入实现
+ */
+type ApiTransport = {
+  /**
+   * 执行一次请求并返回原始响应体
+   */
+  request(request: ApiTransportRequest): Promise<unknown>;
+};
+//#endregion
+//#region src/shared/transport.utils.d.ts
+/**
+ * 本文件由手工终态对齐生成形态维护，定义真源为产品仓 define 定义中心。
+ * 定义真源：产品仓 define 定义中心（见 `lzi-api.config.ts` definitions 入口）。
+ * 重新生成：`bun run api:generate`；一致性校验：`bun run api:check`。
+ */
+/**
+ * 路径参数代入工具，端点函数使用
+ */
+/**
+ * 将路径模板中的参数占位符代入实际值并完成 URL 编码
+ *
+ * @param template - 含参数占位符的路径模板
+ * @param params - 路径参数值集合
+ * @returns 代入并编码后的完整路径
+ * @throws {@link Error} 路径参数缺失时抛出错误
+ */
+declare function buildApiPath(template: string, params: Record<string, unknown>): string;
+//#endregion
+//#region src/domains/graph/graph.dto.d.ts
+/**
+ * 域公共枚举定义：GraphKind
+ */
+declare const GraphKindSchema: z.ZodEnum<{
+  custom: "custom";
+  organization: "organization";
+  person: "person";
+  society: "society";
+}>;
+/**
+ * GraphKind 的推断类型
+ */
+type GraphKind = z.infer<typeof GraphKindSchema>;
+/**
+ * 域公共枚举常量：GraphKind
+ */
+declare const GraphKind: {
+  readonly person: 'person';
+  readonly organization: 'organization';
+  readonly society: 'society';
+  readonly custom: 'custom';
+};
+/**
+ * 空体回执契约，端口成功路径返回 void 的端点共用
+ */
+declare const NullResultSchema: z.ZodLiteral<null>;
+/**
+ * NullResult 的推断类型
+ */
+type NullResult = z.infer<typeof NullResultSchema>;
+/**
+ * 图谱档案镜像
+ */
+declare const GraphProfileSchema: z.ZodObject<{
+  nodeTypes: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    color: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  edgeTypes: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    directed: z.ZodBoolean;
+    dashed: z.ZodOptional<z.ZodBoolean>;
+    dag: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  groupAxes: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    property: z.ZodString;
+    order: z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>;
+  }, z.core.$strip>>;
+  defaultNodeType: z.ZodString;
+  defaultEdgeType: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 图谱档案
+ */
+type GraphProfile = z.infer<typeof GraphProfileSchema>;
+/**
+ * 图谱数据束镜像
+ */
+declare const GraphBundleSchema: z.ZodObject<{
+  graph: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    profile: z.ZodObject<{
+      nodeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      edgeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        directed: z.ZodBoolean;
+        dashed: z.ZodOptional<z.ZodBoolean>;
+        dag: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>>;
+      groupAxes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        property: z.ZodString;
+        order: z.ZodEnum<{
+          asc: "asc";
+          desc: "desc";
+        }>;
+      }, z.core.$strip>>;
+      defaultNodeType: z.ZodString;
+      defaultEdgeType: z.ZodString;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>;
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 图谱数据束
+ */
+type GraphBundle = z.infer<typeof GraphBundleSchema>;
+/**
+ * 图谱实体镜像
+ */
+declare const GraphSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  kind: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  profile: z.ZodOptional<z.ZodObject<{
+    nodeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edgeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      directed: z.ZodBoolean;
+      dashed: z.ZodOptional<z.ZodBoolean>;
+      dag: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    groupAxes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      property: z.ZodString;
+      order: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+      }>;
+    }, z.core.$strip>>;
+    defaultNodeType: z.ZodString;
+    defaultEdgeType: z.ZodString;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Graph 的推断类型
+ */
+type Graph = z.infer<typeof GraphSchema>;
+/**
+ * 域公共数据契约：GraphListData
+ *
+ * 图谱列表四键分页面
+ */
+declare const GraphListDataSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    profile: z.ZodOptional<z.ZodObject<{
+      nodeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      edgeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        directed: z.ZodBoolean;
+        dashed: z.ZodOptional<z.ZodBoolean>;
+        dag: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>>;
+      groupAxes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        property: z.ZodString;
+        order: z.ZodEnum<{
+          asc: "asc";
+          desc: "desc";
+        }>;
+      }, z.core.$strip>>;
+      defaultNodeType: z.ZodString;
+      defaultEdgeType: z.ZodString;
+    }, z.core.$strip>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * GraphListData 的推断类型
+ */
+type GraphListData = z.infer<typeof GraphListDataSchema>;
+//#endregion
+//#region src/domains/graph/graph.schema.d.ts
+/**
+ * 路由常量：POST /api/graphs
+ */
+declare const CreateGraphRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：请求体，POST /api/graphs
+ */
+declare const CreateGraphBodySchema: z.ZodObject<{
+  name: z.ZodString;
+  kind: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  profile: z.ZodOptional<z.ZodObject<{
+    nodeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edgeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      directed: z.ZodBoolean;
+      dashed: z.ZodOptional<z.ZodBoolean>;
+      dag: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    groupAxes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      property: z.ZodString;
+      order: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+      }>;
+    }, z.core.$strip>>;
+    defaultNodeType: z.ZodString;
+    defaultEdgeType: z.ZodString;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * CreateGraphBody 的推断类型
+ */
+type CreateGraphBody = z.infer<typeof CreateGraphBodySchema>;
+/**
+ * 响应 schema，POST /api/graphs
+ */
+declare const CreateGraphResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  kind: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  profile: z.ZodOptional<z.ZodObject<{
+    nodeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edgeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      directed: z.ZodBoolean;
+      dashed: z.ZodOptional<z.ZodBoolean>;
+      dag: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    groupAxes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      property: z.ZodString;
+      order: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+      }>;
+    }, z.core.$strip>>;
+    defaultNodeType: z.ZodString;
+    defaultEdgeType: z.ZodString;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * CreateGraphResponse 的推断类型
+ */
+type CreateGraphResponse = z.infer<typeof CreateGraphResponseSchema>;
+/**
+ * 端点参数契约：创建图谱
+ */
+type CreateGraphArgs = {
+  /**
+   * 请求体
+   */
+  readonly body?: CreateGraphBody;
+};
+/**
+ * 路由常量：GET /api/graphs/:id
+ */
+declare const GetGraphRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 请求 schema：路径参数，GET /api/graphs/:id
+ */
+declare const GetGraphParamsSchema: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 响应 schema，GET /api/graphs/:id
+ *
+ * 端口详情查询可空，图谱不存在时返回 null
+ */
+declare const GetGraphResponseSchema: z.ZodNullable<z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  kind: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  profile: z.ZodOptional<z.ZodObject<{
+    nodeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edgeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      directed: z.ZodBoolean;
+      dashed: z.ZodOptional<z.ZodBoolean>;
+      dag: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    groupAxes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      property: z.ZodString;
+      order: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+      }>;
+    }, z.core.$strip>>;
+    defaultNodeType: z.ZodString;
+    defaultEdgeType: z.ZodString;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetGraphResponse 的推断类型
+ */
+type GetGraphResponse = z.infer<typeof GetGraphResponseSchema>;
+/**
+ * 端点参数契约：获取单个图谱
+ */
+type GetGraphArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GetGraphParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/graphs
+ */
+declare const ListGraphsRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：查询参数，GET /api/graphs
+ */
+declare const ListGraphsQuerySchema: z.ZodObject<{
+  kind: z.ZodOptional<z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  page: z.ZodOptional<z.ZodInt>;
+  pageSize: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * ListGraphsQuery 的推断类型
+ */
+type ListGraphsQuery = z.infer<typeof ListGraphsQuerySchema>;
+/**
+ * 响应 schema，GET /api/graphs
+ */
+declare const ListGraphsResponseSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    profile: z.ZodOptional<z.ZodObject<{
+      nodeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      edgeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        directed: z.ZodBoolean;
+        dashed: z.ZodOptional<z.ZodBoolean>;
+        dag: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>>;
+      groupAxes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        property: z.ZodString;
+        order: z.ZodEnum<{
+          asc: "asc";
+          desc: "desc";
+        }>;
+      }, z.core.$strip>>;
+      defaultNodeType: z.ZodString;
+      defaultEdgeType: z.ZodString;
+    }, z.core.$strip>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * ListGraphsResponse 的推断类型
+ */
+type ListGraphsResponse = z.infer<typeof ListGraphsResponseSchema>;
+/**
+ * 端点参数契约：获取图谱列表
+ */
+type ListGraphsArgs = {
+  /**
+   * 查询参数
+   */
+  readonly query?: ListGraphsQuery;
+};
+/**
+ * 路由常量：PATCH /api/graphs/:id
+ */
+declare const UpdateGraphRoute: {
+  readonly method: 'PATCH';
+  readonly path: '/api/graphs/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 请求 schema：路径参数，PATCH /api/graphs/:id
+ */
+declare const UpdateGraphParamsSchema: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 请求 schema：请求体，PATCH /api/graphs/:id
+ */
+declare const UpdateGraphBodySchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * UpdateGraphBody 的推断类型
+ */
+type UpdateGraphBody = z.infer<typeof UpdateGraphBodySchema>;
+/**
+ * 响应 schema，PATCH /api/graphs/:id
+ */
+declare const UpdateGraphResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  kind: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  profile: z.ZodOptional<z.ZodObject<{
+    nodeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edgeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      directed: z.ZodBoolean;
+      dashed: z.ZodOptional<z.ZodBoolean>;
+      dag: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    groupAxes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      property: z.ZodString;
+      order: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+      }>;
+    }, z.core.$strip>>;
+    defaultNodeType: z.ZodString;
+    defaultEdgeType: z.ZodString;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * UpdateGraphResponse 的推断类型
+ */
+type UpdateGraphResponse = z.infer<typeof UpdateGraphResponseSchema>;
+/**
+ * 端点参数契约：更新图谱
+ */
+type UpdateGraphArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof UpdateGraphParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: UpdateGraphBody;
+};
+/**
+ * 路由常量：DELETE /api/graphs/:id
+ */
+declare const DeleteGraphRoute: {
+  readonly method: 'DELETE';
+  readonly path: '/api/graphs/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 请求 schema：路径参数，DELETE /api/graphs/:id
+ */
+declare const DeleteGraphParamsSchema: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 响应 schema，DELETE /api/graphs/:id
+ *
+ * 端口删除成功路径返回 void，传输层将空体归一为 null
+ */
+declare const DeleteGraphResponseSchema: z.ZodLiteral<null>;
+/**
+ * DeleteGraphResponse 的推断类型
+ */
+type DeleteGraphResponse = z.infer<typeof DeleteGraphResponseSchema>;
+/**
+ * 端点参数契约：删除图谱
+ */
+type DeleteGraphArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof DeleteGraphParamsSchema>;
+};
+/**
+ * 数据束导入路由
+ */
+declare const ImportGraphBundleRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs/import';
+  readonly paramNames: readonly [];
+};
+/**
+ * 数据束导入请求体即完整数据束
+ */
+declare const ImportGraphBundleBodySchema: z.ZodObject<{
+  graph: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    profile: z.ZodObject<{
+      nodeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      edgeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        directed: z.ZodBoolean;
+        dashed: z.ZodOptional<z.ZodBoolean>;
+        dag: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>>;
+      groupAxes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        property: z.ZodString;
+        order: z.ZodEnum<{
+          asc: "asc";
+          desc: "desc";
+        }>;
+      }, z.core.$strip>>;
+      defaultNodeType: z.ZodString;
+      defaultEdgeType: z.ZodString;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>;
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 数据束导入请求体类型
+ */
+type ImportGraphBundleBody = z.infer<typeof ImportGraphBundleBodySchema>;
+/**
+ * 数据束导入响应
+ */
+declare const ImportGraphBundleResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  kind: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  profile: z.ZodOptional<z.ZodObject<{
+    nodeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    edgeTypes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      directed: z.ZodBoolean;
+      dashed: z.ZodOptional<z.ZodBoolean>;
+      dag: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    groupAxes: z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      label: z.ZodString;
+      property: z.ZodString;
+      order: z.ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+      }>;
+    }, z.core.$strip>>;
+    defaultNodeType: z.ZodString;
+    defaultEdgeType: z.ZodString;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 数据束导入响应类型
+ */
+type ImportGraphBundleResponse = z.infer<typeof ImportGraphBundleResponseSchema>;
+/**
+ * 数据束导入入参
+ */
+type ImportGraphBundleArgs = {
+  readonly body: ImportGraphBundleBody;
+};
+/**
+ * 数据束导出路由
+ */
+declare const ExportGraphBundleRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/export';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 数据束导出路径参数
+ */
+declare const ExportGraphBundleParamsSchema: z.ZodObject<{
+  graphId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 数据束导出响应
+ */
+declare const ExportGraphBundleResponseSchema: z.ZodObject<{
+  graph: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    profile: z.ZodObject<{
+      nodeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      edgeTypes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        directed: z.ZodBoolean;
+        dashed: z.ZodOptional<z.ZodBoolean>;
+        dag: z.ZodOptional<z.ZodBoolean>;
+      }, z.core.$strip>>;
+      groupAxes: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodString;
+        property: z.ZodString;
+        order: z.ZodEnum<{
+          asc: "asc";
+          desc: "desc";
+        }>;
+      }, z.core.$strip>>;
+      defaultNodeType: z.ZodString;
+      defaultEdgeType: z.ZodString;
+    }, z.core.$strip>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>;
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 数据束导出响应类型
+ */
+type ExportGraphBundleResponse = z.infer<typeof ExportGraphBundleResponseSchema>;
+/**
+ * 数据束导出入参
+ */
+type ExportGraphBundleArgs = {
+  readonly params: z.infer<typeof ExportGraphBundleParamsSchema>;
+};
+//#endregion
+//#region src/domains/graph/graph.client.d.ts
+/**
+ * graph 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createGraphEndpoints(transport: ApiTransport): {
+  /**
+   * 创建图谱
+   */
+  createGraph: (args: CreateGraphArgs) => Promise<{
+    id: string;
+    name: string;
+    kind: "custom" | "organization" | "person" | "society";
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    profile?: {
+      nodeTypes: {
+        key: string;
+        label: string;
+        color?: string | undefined;
+      }[];
+      edgeTypes: {
+        key: string;
+        label: string;
+        directed: boolean;
+        dashed?: boolean | undefined;
+        dag?: boolean | undefined;
+      }[];
+      groupAxes: {
+        key: string;
+        label: string;
+        property: string;
+        order: "asc" | "desc";
+      }[];
+      defaultNodeType: string;
+      defaultEdgeType: string;
+    } | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 获取单个图谱
+   */
+  getGraph: (args: GetGraphArgs) => Promise<{
+    id: string;
+    name: string;
+    kind: "custom" | "organization" | "person" | "society";
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    profile?: {
+      nodeTypes: {
+        key: string;
+        label: string;
+        color?: string | undefined;
+      }[];
+      edgeTypes: {
+        key: string;
+        label: string;
+        directed: boolean;
+        dashed?: boolean | undefined;
+        dag?: boolean | undefined;
+      }[];
+      groupAxes: {
+        key: string;
+        label: string;
+        property: string;
+        order: "asc" | "desc";
+      }[];
+      defaultNodeType: string;
+      defaultEdgeType: string;
+    } | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+  } | null>;
+  /**
+   * 获取图谱列表
+   */
+  listGraphs: (args: ListGraphsArgs) => Promise<{
+    items: {
+      id: string;
+      name: string;
+      kind: "custom" | "organization" | "person" | "society";
+      description?: string | undefined;
+      metadata?: Record<string, unknown> | undefined;
+      profile?: {
+        nodeTypes: {
+          key: string;
+          label: string;
+          color?: string | undefined;
+        }[];
+        edgeTypes: {
+          key: string;
+          label: string;
+          directed: boolean;
+          dashed?: boolean | undefined;
+          dag?: boolean | undefined;
+        }[];
+        groupAxes: {
+          key: string;
+          label: string;
+          property: string;
+          order: "asc" | "desc";
+        }[];
+        defaultNodeType: string;
+        defaultEdgeType: string;
+      } | undefined;
+      tenantId?: string | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    total: number;
+    page: number;
+    pageSize: number;
+  }>;
+  /**
+   * 更新图谱
+   */
+  updateGraph: (args: UpdateGraphArgs) => Promise<{
+    id: string;
+    name: string;
+    kind: "custom" | "organization" | "person" | "society";
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    profile?: {
+      nodeTypes: {
+        key: string;
+        label: string;
+        color?: string | undefined;
+      }[];
+      edgeTypes: {
+        key: string;
+        label: string;
+        directed: boolean;
+        dashed?: boolean | undefined;
+        dag?: boolean | undefined;
+      }[];
+      groupAxes: {
+        key: string;
+        label: string;
+        property: string;
+        order: "asc" | "desc";
+      }[];
+      defaultNodeType: string;
+      defaultEdgeType: string;
+    } | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 删除图谱
+   */
+  deleteGraph: (args: DeleteGraphArgs) => Promise<null>;
+  /**
+   * importGraphBundle 端点
+   */
+  importGraphBundle: (args: ImportGraphBundleArgs) => Promise<{
+    id: string;
+    name: string;
+    kind: "custom" | "organization" | "person" | "society";
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    profile?: {
+      nodeTypes: {
+        key: string;
+        label: string;
+        color?: string | undefined;
+      }[];
+      edgeTypes: {
+        key: string;
+        label: string;
+        directed: boolean;
+        dashed?: boolean | undefined;
+        dag?: boolean | undefined;
+      }[];
+      groupAxes: {
+        key: string;
+        label: string;
+        property: string;
+        order: "asc" | "desc";
+      }[];
+      defaultNodeType: string;
+      defaultEdgeType: string;
+    } | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * exportGraphBundle 端点
+   */
+  exportGraphBundle: (args: ExportGraphBundleArgs) => Promise<{
+    graph: {
+      name: string;
+      kind: "custom" | "organization" | "person" | "society";
+      description?: string | undefined;
+      profile: {
+        nodeTypes: {
+          key: string;
+          label: string;
+          color?: string | undefined;
+        }[];
+        edgeTypes: {
+          key: string;
+          label: string;
+          directed: boolean;
+          dashed?: boolean | undefined;
+          dag?: boolean | undefined;
+        }[];
+        groupAxes: {
+          key: string;
+          label: string;
+          property: string;
+          order: "asc" | "desc";
+        }[];
+        defaultNodeType: string;
+        defaultEdgeType: string;
+      };
+      metadata?: Record<string, unknown> | undefined;
+    };
+    nodes: {
+      id: string;
+      label: string;
+      nodeType: string;
+      properties?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+      id?: string | undefined;
+      sourceId: string;
+      targetId: string;
+      edgeType: string;
+      label?: string | undefined;
+      properties?: Record<string, unknown> | undefined;
+      weight?: number | undefined;
+    }[];
+  }>;
+};
+//#endregion
+//#region src/domains/graph-node/graph-node.dto.d.ts
+/**
+ * 域公共枚举定义：NodeType
+ */
+declare const NodeTypeSchema: z.ZodString;
+/**
+ * NodeType 的推断类型
+ */
+type NodeType = z.infer<typeof NodeTypeSchema>;
+/**
+ * 域公共枚举常量：NodeType
+ */
+/**
+ * 默认档案的节点类型键集，供消费方提示内置键
+ */
+declare const NodeType: {
+  readonly person: 'person';
+  readonly organization: 'organization';
+  readonly concept: 'concept';
+  readonly event: 'event';
+  readonly location: 'location';
+  readonly custom: 'custom';
+};
+/**
+ * 域公共数据契约：Node
+ *
+ * 节点自定义属性为任意键值面，生成器封闭集不支持，按领域现实保留
+ */
+declare const NodeSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  label: z.ZodString;
+  nodeType: z.ZodString;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Node 的推断类型
+ */
+type Node = z.infer<typeof NodeSchema>;
+/**
+ * 域公共数据契约：NodeListData
+ *
+ * 节点列表四键分页面
+ */
+declare const NodeListDataSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * NodeListData 的推断类型
+ */
+type NodeListData = z.infer<typeof NodeListDataSchema>;
+//#endregion
+//#region src/domains/graph-node/graph-node.schema.d.ts
+/**
+ * 图谱归属路径参数契约，节点路由共用
+ */
+declare const GraphScopedParamsSchema: z.ZodObject<{
+  graphId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 图谱子资源路径参数契约，节点单资源路由共用
+ */
+declare const GraphScopedIdParamsSchema: z.ZodObject<{
+  graphId: z.ZodString;
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 路由常量：POST /api/graphs/:graphId/nodes
+ */
+declare const CreateNodeRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs/:graphId/nodes';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 请求 schema：请求体，POST /api/graphs/:graphId/nodes
+ */
+declare const CreateNodeBodySchema: z.ZodObject<{
+  graphId: z.ZodString;
+  label: z.ZodString;
+  nodeType: z.ZodString;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * CreateNodeBody 的推断类型
+ */
+type CreateNodeBody = z.infer<typeof CreateNodeBodySchema>;
+/**
+ * 响应 schema，POST /api/graphs/:graphId/nodes
+ */
+declare const CreateNodeResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  label: z.ZodString;
+  nodeType: z.ZodString;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * CreateNodeResponse 的推断类型
+ */
+type CreateNodeResponse = z.infer<typeof CreateNodeResponseSchema>;
+/**
+ * 端点参数契约：创建节点
+ */
+type CreateNodeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: CreateNodeBody;
+};
+/**
+ * 路由常量：GET /api/graphs/:graphId/nodes/:id
+ */
+declare const GetNodeRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/nodes/:id';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 响应 schema，GET /api/graphs/:graphId/nodes/:id
+ *
+ * 端口详情查询可空，节点不存在时返回 null
+ */
+declare const GetNodeResponseSchema: z.ZodNullable<z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  label: z.ZodString;
+  nodeType: z.ZodString;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetNodeResponse 的推断类型
+ */
+type GetNodeResponse = z.infer<typeof GetNodeResponseSchema>;
+/**
+ * 端点参数契约：获取单个节点
+ */
+type GetNodeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/graphs/:graphId/nodes
+ */
+declare const ListNodesRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/nodes';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 请求 schema：查询参数，GET /api/graphs/:graphId/nodes
+ *
+ * 所属图谱标识经路径参数传递
+ */
+declare const ListNodesQuerySchema: z.ZodObject<{
+  nodeType: z.ZodOptional<z.ZodString>;
+  page: z.ZodOptional<z.ZodInt>;
+  pageSize: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * ListNodesQuery 的推断类型
+ */
+type ListNodesQuery = z.infer<typeof ListNodesQuerySchema>;
+/**
+ * 响应 schema，GET /api/graphs/:graphId/nodes
+ */
+declare const ListNodesResponseSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * ListNodesResponse 的推断类型
+ */
+type ListNodesResponse = z.infer<typeof ListNodesResponseSchema>;
+/**
+ * 端点参数契约：获取节点列表
+ */
+type ListNodesArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  /**
+   * 查询参数
+   */
+  readonly query?: ListNodesQuery;
+};
+/**
+ * 路由常量：PATCH /api/graphs/:graphId/nodes/:id
+ */
+declare const UpdateNodeRoute: {
+  readonly method: 'PATCH';
+  readonly path: '/api/graphs/:graphId/nodes/:id';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 请求 schema：请求体，PATCH /api/graphs/:graphId/nodes/:id
+ */
+declare const UpdateNodeBodySchema: z.ZodObject<{
+  label: z.ZodOptional<z.ZodString>;
+  nodeType: z.ZodOptional<z.ZodString>;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * UpdateNodeBody 的推断类型
+ */
+type UpdateNodeBody = z.infer<typeof UpdateNodeBodySchema>;
+/**
+ * 响应 schema，PATCH /api/graphs/:graphId/nodes/:id
+ */
+declare const UpdateNodeResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  label: z.ZodString;
+  nodeType: z.ZodString;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * UpdateNodeResponse 的推断类型
+ */
+type UpdateNodeResponse = z.infer<typeof UpdateNodeResponseSchema>;
+/**
+ * 端点参数契约：更新节点
+ */
+type UpdateNodeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: UpdateNodeBody;
+};
+/**
+ * 路由常量：DELETE /api/graphs/:graphId/nodes/:id
+ */
+declare const DeleteNodeRoute: {
+  readonly method: 'DELETE';
+  readonly path: '/api/graphs/:graphId/nodes/:id';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 响应 schema，DELETE /api/graphs/:graphId/nodes/:id
+ *
+ * 端口删除成功路径返回 void，传输层将空体归一为 null
+ */
+declare const DeleteNodeResponseSchema: z.ZodLiteral<null>;
+/**
+ * DeleteNodeResponse 的推断类型
+ */
+type DeleteNodeResponse = z.infer<typeof DeleteNodeResponseSchema>;
+/**
+ * 端点参数契约：删除节点
+ */
+type DeleteNodeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+};
+//#endregion
+//#region src/domains/graph-node/graph-node.client.d.ts
+/**
+ * graph-node 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createGraphNodeEndpoints(transport: ApiTransport): {
+  /**
+   * 创建节点
+   */
+  createNode: (args: CreateNodeArgs) => Promise<{
+    id: string;
+    graphId: string;
+    label: string;
+    nodeType: string;
+    properties?: Record<string, unknown> | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 获取单个节点
+   */
+  getNode: (args: GetNodeArgs) => Promise<{
+    id: string;
+    graphId: string;
+    label: string;
+    nodeType: string;
+    properties?: Record<string, unknown> | undefined;
+    createdAt: string;
+    updatedAt: string;
+  } | null>;
+  /**
+   * 获取节点列表
+   */
+  listNodes: (args: ListNodesArgs) => Promise<{
+    items: {
+      id: string;
+      graphId: string;
+      label: string;
+      nodeType: string;
+      properties?: Record<string, unknown> | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    total: number;
+    page: number;
+    pageSize: number;
+  }>;
+  /**
+   * 更新节点
+   */
+  updateNode: (args: UpdateNodeArgs) => Promise<{
+    id: string;
+    graphId: string;
+    label: string;
+    nodeType: string;
+    properties?: Record<string, unknown> | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 删除节点
+   */
+  deleteNode: (args: DeleteNodeArgs) => Promise<null>;
+};
+//#endregion
+//#region src/domains/graph-edge/graph-edge.dto.d.ts
+/**
+ * 域公共枚举定义：EdgeType
+ */
+declare const EdgeTypeSchema: z.ZodString;
+/**
+ * EdgeType 的推断类型
+ */
+type EdgeType = z.infer<typeof EdgeTypeSchema>;
+/**
+ * 域公共枚举常量：EdgeType
+ */
+/**
+ * 默认档案的边类型键集，供消费方提示内置键
+ */
+declare const EdgeType: {
+  readonly knows: 'knows';
+  readonly works_for: 'works_for';
+  readonly member_of: 'member_of';
+  readonly related_to: 'related_to';
+  readonly located_in: 'located_in';
+  readonly custom: 'custom';
+};
+/**
+ * 域公共数据契约：Edge
+ *
+ * 边自定义属性为任意键值面，生成器封闭集不支持，按领域现实保留
+ */
+declare const EdgeSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  sourceId: z.ZodString;
+  targetId: z.ZodString;
+  edgeType: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  weight: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Edge 的推断类型
+ */
+type Edge = z.infer<typeof EdgeSchema>;
+/**
+ * 域公共数据契约：EdgeListData
+ *
+ * 边列表四键分页面
+ */
+declare const EdgeListDataSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * EdgeListData 的推断类型
+ */
+type EdgeListData = z.infer<typeof EdgeListDataSchema>;
+//#endregion
+//#region src/domains/graph-edge/graph-edge.schema.d.ts
+/**
+ * 路由常量：POST /api/graphs/:graphId/edges
+ */
+declare const CreateEdgeRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs/:graphId/edges';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 请求 schema：请求体，POST /api/graphs/:graphId/edges
+ */
+declare const CreateEdgeBodySchema: z.ZodObject<{
+  graphId: z.ZodString;
+  sourceId: z.ZodString;
+  targetId: z.ZodString;
+  edgeType: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * CreateEdgeBody 的推断类型
+ */
+type CreateEdgeBody = z.infer<typeof CreateEdgeBodySchema>;
+/**
+ * 响应 schema，POST /api/graphs/:graphId/edges
+ */
+declare const CreateEdgeResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  sourceId: z.ZodString;
+  targetId: z.ZodString;
+  edgeType: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  weight: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * CreateEdgeResponse 的推断类型
+ */
+type CreateEdgeResponse = z.infer<typeof CreateEdgeResponseSchema>;
+/**
+ * 端点参数契约：创建边
+ */
+type CreateEdgeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: CreateEdgeBody;
+};
+/**
+ * 路由常量：GET /api/graphs/:graphId/edges/:id
+ */
+declare const GetEdgeRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/edges/:id';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 响应 schema，GET /api/graphs/:graphId/edges/:id
+ *
+ * 端口详情查询可空，边不存在时返回 null
+ */
+declare const GetEdgeResponseSchema: z.ZodNullable<z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  sourceId: z.ZodString;
+  targetId: z.ZodString;
+  edgeType: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  weight: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetEdgeResponse 的推断类型
+ */
+type GetEdgeResponse = z.infer<typeof GetEdgeResponseSchema>;
+/**
+ * 端点参数契约：获取单个边
+ */
+type GetEdgeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/graphs/:graphId/edges
+ */
+declare const ListEdgesRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/edges';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 请求 schema：查询参数，GET /api/graphs/:graphId/edges
+ *
+ * 所属图谱标识经路径参数传递
+ */
+declare const ListEdgesQuerySchema: z.ZodObject<{
+  edgeType: z.ZodOptional<z.ZodString>;
+  sourceId: z.ZodOptional<z.ZodString>;
+  targetId: z.ZodOptional<z.ZodString>;
+  page: z.ZodOptional<z.ZodInt>;
+  pageSize: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * ListEdgesQuery 的推断类型
+ */
+type ListEdgesQuery = z.infer<typeof ListEdgesQuerySchema>;
+/**
+ * 响应 schema，GET /api/graphs/:graphId/edges
+ */
+declare const ListEdgesResponseSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * ListEdgesResponse 的推断类型
+ */
+type ListEdgesResponse = z.infer<typeof ListEdgesResponseSchema>;
+/**
+ * 端点参数契约：获取边列表
+ */
+type ListEdgesArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  /**
+   * 查询参数
+   */
+  readonly query?: ListEdgesQuery;
+};
+/**
+ * 路由常量：PATCH /api/graphs/:graphId/edges/:id
+ */
+declare const UpdateEdgeRoute: {
+  readonly method: 'PATCH';
+  readonly path: '/api/graphs/:graphId/edges/:id';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 请求 schema：请求体，PATCH /api/graphs/:graphId/edges/:id
+ */
+declare const UpdateEdgeBodySchema: z.ZodObject<{
+  label: z.ZodOptional<z.ZodString>;
+  edgeType: z.ZodOptional<z.ZodString>;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  weight: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * UpdateEdgeBody 的推断类型
+ */
+type UpdateEdgeBody = z.infer<typeof UpdateEdgeBodySchema>;
+/**
+ * 响应 schema，PATCH /api/graphs/:graphId/edges/:id
+ */
+declare const UpdateEdgeResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  sourceId: z.ZodString;
+  targetId: z.ZodString;
+  edgeType: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  weight: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * UpdateEdgeResponse 的推断类型
+ */
+type UpdateEdgeResponse = z.infer<typeof UpdateEdgeResponseSchema>;
+/**
+ * 端点参数契约：更新边
+ */
+type UpdateEdgeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: UpdateEdgeBody;
+};
+/**
+ * 路由常量：DELETE /api/graphs/:graphId/edges/:id
+ */
+declare const DeleteEdgeRoute: {
+  readonly method: 'DELETE';
+  readonly path: '/api/graphs/:graphId/edges/:id';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 响应 schema，DELETE /api/graphs/:graphId/edges/:id
+ *
+ * 端口删除成功路径返回 void，传输层将空体归一为 null
+ */
+declare const DeleteEdgeResponseSchema: z.ZodLiteral<null>;
+/**
+ * DeleteEdgeResponse 的推断类型
+ */
+type DeleteEdgeResponse = z.infer<typeof DeleteEdgeResponseSchema>;
+/**
+ * 端点参数契约：删除边
+ */
+type DeleteEdgeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+};
+//#endregion
+//#region src/domains/graph-edge/graph-edge.client.d.ts
+/**
+ * graph-edge 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createGraphEdgeEndpoints(transport: ApiTransport): {
+  /**
+   * 创建边
+   */
+  createEdge: (args: CreateEdgeArgs) => Promise<{
+    id: string;
+    graphId: string;
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    label?: string | undefined;
+    properties?: Record<string, unknown> | undefined;
+    weight?: number | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 获取单个边
+   */
+  getEdge: (args: GetEdgeArgs) => Promise<{
+    id: string;
+    graphId: string;
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    label?: string | undefined;
+    properties?: Record<string, unknown> | undefined;
+    weight?: number | undefined;
+    createdAt: string;
+    updatedAt: string;
+  } | null>;
+  /**
+   * 获取边列表
+   */
+  listEdges: (args: ListEdgesArgs) => Promise<{
+    items: {
+      id: string;
+      graphId: string;
+      sourceId: string;
+      targetId: string;
+      edgeType: string;
+      label?: string | undefined;
+      properties?: Record<string, unknown> | undefined;
+      weight?: number | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    total: number;
+    page: number;
+    pageSize: number;
+  }>;
+  /**
+   * 更新边
+   */
+  updateEdge: (args: UpdateEdgeArgs) => Promise<{
+    id: string;
+    graphId: string;
+    sourceId: string;
+    targetId: string;
+    edgeType: string;
+    label?: string | undefined;
+    properties?: Record<string, unknown> | undefined;
+    weight?: number | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 删除边
+   */
+  deleteEdge: (args: DeleteEdgeArgs) => Promise<null>;
+};
+//#endregion
+//#region src/domains/graph-query/graph-query.dto.d.ts
+/**
+ * 域公共枚举定义：TraverseDirection
+ */
+declare const TraverseDirectionSchema: z.ZodEnum<{
+  both: "both";
+  in: "in";
+  out: "out";
+}>;
+/**
+ * TraverseDirection 的推断类型
+ */
+type TraverseDirection = z.infer<typeof TraverseDirectionSchema>;
+/**
+ * 域公共枚举常量：TraverseDirection
+ */
+declare const TraverseDirection: {
+  readonly out: 'out';
+  readonly in: 'in';
+  readonly both: 'both';
+};
+/**
+ * 域公共数据契约：NeighborsData
+ *
+ * 端口邻居查询返回起始节点标识与邻居节点列表
+ */
+declare const NeighborsDataSchema: z.ZodObject<{
+  nodeId: z.ZodString;
+  neighbors: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * NeighborsData 的推断类型
+ */
+type NeighborsData = z.infer<typeof NeighborsDataSchema>;
+/**
+ * 域公共数据契约：TraverseData
+ *
+ * 端口遍历返回起点、访问到的节点列表与最大深度
+ */
+declare const TraverseDataSchema: z.ZodObject<{
+  startNodeId: z.ZodString;
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  depth: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * TraverseData 的推断类型
+ */
+type TraverseData = z.infer<typeof TraverseDataSchema>;
+/**
+ * 带层级的遍历节点
+ */
+declare const TraverseNodeSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  label: z.ZodString;
+  nodeType: z.ZodString;
+  properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+  depth: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * 带层级的遍历节点推断类型
+ */
+type TraverseNode = z.infer<typeof TraverseNodeSchema>;
+/**
+ * 图切片即节点列表加两端都在集内的边列表
+ */
+declare const GraphSliceDataSchema: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 图切片推断类型
+ */
+type GraphSliceData = z.infer<typeof GraphSliceDataSchema>;
+/**
+ * 标识列表即拓扑序、传递约简与学习路径的返回面
+ */
+declare const IdListDataSchema: z.ZodArray<z.ZodString>;
+/**
+ * 标识列表推断类型
+ */
+type IdListData = z.infer<typeof IdListDataSchema>;
+/**
+ * 分组轴定义镜像
+ */
+declare const GroupFoldAxisSchema: z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  property: z.ZodString;
+  order: z.ZodEnum<{
+    asc: "asc";
+    desc: "desc";
+  }>;
+}, z.core.$strip>;
+/**
+ * 分组轴推断类型
+ */
+type GroupFoldAxis = z.infer<typeof GroupFoldAxisSchema>;
+/**
+ * 分组折叠结果
+ */
+declare const GroupFoldDataSchema: z.ZodObject<{
+  axis: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    property: z.ZodString;
+    order: z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>;
+  }, z.core.$strip>;
+  groups: z.ZodArray<z.ZodObject<{
+    value: z.ZodString;
+    nodeIds: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 分组折叠结果推断类型
+ */
+type GroupFoldData = z.infer<typeof GroupFoldDataSchema>;
+//#endregion
+//#region src/domains/graph-query/graph-query.schema.d.ts
+/**
+ * 路由常量：GET /api/graphs/:graphId/nodes/:id/neighbors
+ */
+declare const GetNeighborsRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/nodes/:id/neighbors';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 响应 schema，GET /api/graphs/:graphId/nodes/:id/neighbors
+ */
+declare const GetNeighborsResponseSchema: z.ZodObject<{
+  nodeId: z.ZodString;
+  neighbors: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * GetNeighborsResponse 的推断类型
+ */
+type GetNeighborsResponse = z.infer<typeof GetNeighborsResponseSchema>;
+/**
+ * 端点参数契约：获取节点邻居
+ */
+type GetNeighborsArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+};
+/**
+ * 路由常量：POST /api/graphs/:graphId/traverse
+ */
+declare const TraverseGraphRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs/:graphId/traverse';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 请求 schema：请求体，POST /api/graphs/:graphId/traverse
+ *
+ * 端口入参为起点、方向与深度，无边类型过滤键
+ */
+declare const TraverseGraphBodySchema: z.ZodObject<{
+  startNodeId: z.ZodString;
+  direction: z.ZodOptional<z.ZodEnum<{
+    both: "both";
+    in: "in";
+    out: "out";
+  }>>;
+  maxDepth: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * TraverseGraphBody 的推断类型
+ */
+type TraverseGraphBody = z.infer<typeof TraverseGraphBodySchema>;
+/**
+ * 响应 schema，POST /api/graphs/:graphId/traverse
+ */
+declare const TraverseGraphResponseSchema: z.ZodObject<{
+  startNodeId: z.ZodString;
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  depth: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * TraverseGraphResponse 的推断类型
+ */
+type TraverseGraphResponse = z.infer<typeof TraverseGraphResponseSchema>;
+/**
+ * 端点参数契约：图遍历
+ */
+type TraverseGraphArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: TraverseGraphBody;
+};
+/**
+ * 祖先与后代查询共用查询串
+ */
+declare const GraphQueryParamsWireSchema: z.ZodObject<{
+  depth: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+  edgeTypes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * 祖先查询路由
+ */
+declare const GetAncestorsRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/nodes/:id/ancestors';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 祖先查询响应
+ */
+declare const GetAncestorsResponseSchema: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 祖先查询响应类型
+ */
+type GetAncestorsResponse = z.infer<typeof GetAncestorsResponseSchema>;
+/**
+ * 祖先查询入参
+ */
+type GetAncestorsArgs = {
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+  readonly query?: z.infer<typeof GraphQueryParamsWireSchema>;
+};
+/**
+ * 后代查询路由
+ */
+declare const GetDescendantsRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/nodes/:id/descendants';
+  readonly paramNames: readonly ['graphId', 'id'];
+};
+/**
+ * 后代查询响应
+ */
+declare const GetDescendantsResponseSchema: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 后代查询响应类型
+ */
+type GetDescendantsResponse = z.infer<typeof GetDescendantsResponseSchema>;
+/**
+ * 后代查询入参
+ */
+type GetDescendantsArgs = {
+  readonly params: z.infer<typeof GraphScopedIdParamsSchema>;
+  readonly query?: z.infer<typeof GraphQueryParamsWireSchema>;
+};
+/**
+ * 子图查询路由
+ */
+declare const GetSubgraphRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs/:graphId/subgraph';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 子图查询请求体
+ */
+declare const GetSubgraphBodySchema: z.ZodObject<{
+  nodeIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * 子图查询请求体类型
+ */
+type GetSubgraphBody = z.infer<typeof GetSubgraphBodySchema>;
+/**
+ * 子图查询响应
+ */
+declare const GetSubgraphResponseSchema: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    label: z.ZodString;
+    nodeType: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    sourceId: z.ZodString;
+    targetId: z.ZodString;
+    edgeType: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    weight: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 子图查询响应类型
+ */
+type GetSubgraphResponse = z.infer<typeof GetSubgraphResponseSchema>;
+/**
+ * 子图查询入参
+ */
+type GetSubgraphArgs = {
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  readonly body: GetSubgraphBody;
+};
+/**
+ * 拓扑序查询路由
+ */
+declare const GetTopologicalOrderRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/topological-order';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 拓扑序查询串
+ */
+declare const GetTopologicalOrderQuerySchema: z.ZodObject<{
+  edgeTypes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * 拓扑序响应
+ */
+declare const GetTopologicalOrderResponseSchema: z.ZodArray<z.ZodString>;
+/**
+ * 拓扑序响应类型
+ */
+type GetTopologicalOrderResponse = z.infer<typeof GetTopologicalOrderResponseSchema>;
+/**
+ * 拓扑序入参
+ */
+type GetTopologicalOrderArgs = {
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  readonly query?: z.infer<typeof GetTopologicalOrderQuerySchema>;
+};
+/**
+ * 传递约简路由
+ */
+declare const GetTransitiveReductionRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs/:graphId/transitive-reduction';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 传递约简请求体
+ */
+declare const GetTransitiveReductionBodySchema: z.ZodObject<{
+  nodeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * 传递约简请求体类型
+ */
+type GetTransitiveReductionBody = z.infer<typeof GetTransitiveReductionBodySchema>;
+/**
+ * 传递约简响应
+ */
+declare const GetTransitiveReductionResponseSchema: z.ZodArray<z.ZodString>;
+/**
+ * 传递约简响应类型
+ */
+type GetTransitiveReductionResponse = z.infer<typeof GetTransitiveReductionResponseSchema>;
+/**
+ * 传递约简入参
+ */
+type GetTransitiveReductionArgs = {
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  readonly body?: GetTransitiveReductionBody;
+};
+/**
+ * 分组折叠路由
+ */
+declare const GetGroupFoldRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/graphs/:graphId/group-fold/:axisKey';
+  readonly paramNames: readonly ['graphId', 'axisKey'];
+};
+/**
+ * 分组折叠路径参数
+ */
+declare const GroupAxisParamsSchema: z.ZodObject<{
+  graphId: z.ZodString;
+  axisKey: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 分组折叠查询串
+ */
+declare const GetGroupFoldQuerySchema: z.ZodObject<{
+  nodeIds: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * 分组折叠响应
+ */
+declare const GetGroupFoldResponseSchema: z.ZodObject<{
+  axis: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    property: z.ZodString;
+    order: z.ZodEnum<{
+      asc: "asc";
+      desc: "desc";
+    }>;
+  }, z.core.$strip>;
+  groups: z.ZodArray<z.ZodObject<{
+    value: z.ZodString;
+    nodeIds: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * 分组折叠响应类型
+ */
+type GetGroupFoldResponse = z.infer<typeof GetGroupFoldResponseSchema>;
+/**
+ * 分组折叠入参
+ */
+type GetGroupFoldArgs = {
+  readonly params: z.infer<typeof GroupAxisParamsSchema>;
+  readonly query?: z.infer<typeof GetGroupFoldQuerySchema>;
+};
+/**
+ * 学习路径路由
+ */
+declare const GetLearningPathRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/graphs/:graphId/learning-path';
+  readonly paramNames: readonly ['graphId'];
+};
+/**
+ * 学习路径请求体
+ */
+declare const GetLearningPathBodySchema: z.ZodObject<{
+  seeds: z.ZodArray<z.ZodString>;
+  orderAxisKey: z.ZodString;
+  edgeTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * 学习路径请求体类型
+ */
+type GetLearningPathBody = z.infer<typeof GetLearningPathBodySchema>;
+/**
+ * 学习路径响应
+ */
+declare const GetLearningPathResponseSchema: z.ZodArray<z.ZodString>;
+/**
+ * 学习路径响应类型
+ */
+type GetLearningPathResponse = z.infer<typeof GetLearningPathResponseSchema>;
+/**
+ * 学习路径入参
+ */
+type GetLearningPathArgs = {
+  readonly params: z.infer<typeof GraphScopedParamsSchema>;
+  readonly body: GetLearningPathBody;
+};
+//#endregion
+//#region src/domains/graph-query/graph-query.client.d.ts
+/**
+ * graph-query 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createGraphQueryEndpoints(transport: ApiTransport): {
+  /**
+   * 获取节点邻居
+   */
+  getNeighbors: (args: GetNeighborsArgs) => Promise<{
+    nodeId: string;
+    neighbors: {
+      id: string;
+      graphId: string;
+      label: string;
+      nodeType: string;
+      properties?: Record<string, unknown> | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+  }>;
+  /**
+   * 图遍历
+   */
+  traverseGraph: (args: TraverseGraphArgs) => Promise<{
+    startNodeId: string;
+    nodes: {
+      id: string;
+      graphId: string;
+      label: string;
+      nodeType: string;
+      properties?: Record<string, unknown> | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    depth: number;
+  }>;
+  /**
+   * 祖先切片端点
+   */
+  getAncestors: (args: GetAncestorsArgs) => Promise<{
+    nodes: {
+      id: string;
+      graphId: string;
+      label: string;
+      nodeType: string;
+      properties?: Record<string, unknown> | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    edges: {
+      id: string;
+      graphId: string;
+      sourceId: string;
+      targetId: string;
+      edgeType: string;
+      label?: string | undefined;
+      properties?: Record<string, unknown> | undefined;
+      weight?: number | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+  }>;
+  /**
+   * getDescendants 端点
+   */
+  getDescendants: (args: GetDescendantsArgs) => Promise<{
+    nodes: {
+      id: string;
+      graphId: string;
+      label: string;
+      nodeType: string;
+      properties?: Record<string, unknown> | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    edges: {
+      id: string;
+      graphId: string;
+      sourceId: string;
+      targetId: string;
+      edgeType: string;
+      label?: string | undefined;
+      properties?: Record<string, unknown> | undefined;
+      weight?: number | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+  }>;
+  /**
+   * getSubgraph 端点
+   */
+  getSubgraph: (args: GetSubgraphArgs) => Promise<{
+    nodes: {
+      id: string;
+      graphId: string;
+      label: string;
+      nodeType: string;
+      properties?: Record<string, unknown> | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    edges: {
+      id: string;
+      graphId: string;
+      sourceId: string;
+      targetId: string;
+      edgeType: string;
+      label?: string | undefined;
+      properties?: Record<string, unknown> | undefined;
+      weight?: number | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+  }>;
+  /**
+   * getTopologicalOrder 端点
+   */
+  getTopologicalOrder: (args: GetTopologicalOrderArgs) => Promise<string[]>;
+  /**
+   * getTransitiveReduction 端点
+   */
+  getTransitiveReduction: (args: GetTransitiveReductionArgs) => Promise<string[]>;
+  /**
+   * getGroupFold 端点
+   */
+  getGroupFold: (args: GetGroupFoldArgs) => Promise<{
+    axis: {
+      key: string;
+      label: string;
+      property: string;
+      order: "asc" | "desc";
+    };
+    groups: {
+      value: string;
+      nodeIds: string[];
+    }[];
+  }>;
+  /**
+   * getLearningPath 端点
+   */
+  getLearningPath: (args: GetLearningPathArgs) => Promise<string[]>;
+};
+//#endregion
+//#region src/domains/layer/layer.dto.d.ts
+/**
+ * 域公共枚举定义：LayerType
+ */
+declare const LayerTypeSchema: z.ZodEnum<{
+  custom: "custom";
+  organization: "organization";
+  person: "person";
+  society: "society";
+}>;
+/**
+ * LayerType 的推断类型
+ */
+type LayerType = z.infer<typeof LayerTypeSchema>;
+/**
+ * 域公共枚举常量：LayerType
+ */
+declare const LayerType: {
+  readonly person: 'person';
+  readonly organization: 'organization';
+  readonly society: 'society';
+  readonly custom: 'custom';
+};
+/**
+ * 域公共数据契约：Layer
+ *
+ * 图层元数据为任意键值面，生成器封闭集不支持，按领域现实保留
+ */
+declare const LayerSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  name: z.ZodString;
+  layerType: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Layer 的推断类型
+ */
+type Layer = z.infer<typeof LayerSchema>;
+/**
+ * 域公共数据契约：LayerListData
+ *
+ * 图层列表四键分页面
+ */
+declare const LayerListDataSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    name: z.ZodString;
+    layerType: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * LayerListData 的推断类型
+ */
+type LayerListData = z.infer<typeof LayerListDataSchema>;
+//#endregion
+//#region src/domains/layer/layer.schema.d.ts
+/**
+ * 图层标识路径参数契约，图层单资源路由共用
+ */
+declare const LayerIdParamsSchema: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 路由常量：POST /api/layers
+ */
+declare const CreateLayerRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/layers';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：请求体，POST /api/layers
+ */
+declare const CreateLayerBodySchema: z.ZodObject<{
+  graphId: z.ZodString;
+  name: z.ZodString;
+  layerType: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * CreateLayerBody 的推断类型
+ */
+type CreateLayerBody = z.infer<typeof CreateLayerBodySchema>;
+/**
+ * 响应 schema，POST /api/layers
+ */
+declare const CreateLayerResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  name: z.ZodString;
+  layerType: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * CreateLayerResponse 的推断类型
+ */
+type CreateLayerResponse = z.infer<typeof CreateLayerResponseSchema>;
+/**
+ * 端点参数契约：创建图层
+ */
+type CreateLayerArgs = {
+  /**
+   * 请求体
+   */
+  readonly body?: CreateLayerBody;
+};
+/**
+ * 路由常量：GET /api/layers/:id
+ */
+declare const GetLayerRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/layers/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 响应 schema，GET /api/layers/:id
+ *
+ * 端口详情查询可空，图层不存在时返回 null
+ */
+declare const GetLayerResponseSchema: z.ZodNullable<z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  name: z.ZodString;
+  layerType: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetLayerResponse 的推断类型
+ */
+type GetLayerResponse = z.infer<typeof GetLayerResponseSchema>;
+/**
+ * 端点参数契约：获取单个图层
+ */
+type GetLayerArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof LayerIdParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/layers
+ */
+declare const ListLayersRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/layers';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：查询参数，GET /api/layers
+ */
+declare const ListLayersQuerySchema: z.ZodObject<{
+  graphId: z.ZodOptional<z.ZodString>;
+  layerType: z.ZodOptional<z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  page: z.ZodOptional<z.ZodInt>;
+  pageSize: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * ListLayersQuery 的推断类型
+ */
+type ListLayersQuery = z.infer<typeof ListLayersQuerySchema>;
+/**
+ * 响应 schema，GET /api/layers
+ */
+declare const ListLayersResponseSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    name: z.ZodString;
+    layerType: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * ListLayersResponse 的推断类型
+ */
+type ListLayersResponse = z.infer<typeof ListLayersResponseSchema>;
+/**
+ * 端点参数契约：获取图层列表
+ */
+type ListLayersArgs = {
+  /**
+   * 查询参数
+   */
+  readonly query?: ListLayersQuery;
+};
+/**
+ * 路由常量：PATCH /api/layers/:id
+ */
+declare const UpdateLayerRoute: {
+  readonly method: 'PATCH';
+  readonly path: '/api/layers/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 请求 schema：请求体，PATCH /api/layers/:id
+ */
+declare const UpdateLayerBodySchema: z.ZodObject<{
+  name: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * UpdateLayerBody 的推断类型
+ */
+type UpdateLayerBody = z.infer<typeof UpdateLayerBodySchema>;
+/**
+ * 响应 schema，PATCH /api/layers/:id
+ */
+declare const UpdateLayerResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  graphId: z.ZodString;
+  name: z.ZodString;
+  layerType: z.ZodEnum<{
+    custom: "custom";
+    organization: "organization";
+    person: "person";
+    society: "society";
+  }>;
+  description: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * UpdateLayerResponse 的推断类型
+ */
+type UpdateLayerResponse = z.infer<typeof UpdateLayerResponseSchema>;
+/**
+ * 端点参数契约：更新图层
+ */
+type UpdateLayerArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof LayerIdParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: UpdateLayerBody;
+};
+/**
+ * 路由常量：DELETE /api/layers/:id
+ */
+declare const DeleteLayerRoute: {
+  readonly method: 'DELETE';
+  readonly path: '/api/layers/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 响应 schema，DELETE /api/layers/:id
+ *
+ * 端口删除成功路径返回 void，传输层将空体归一为 null
+ */
+declare const DeleteLayerResponseSchema: z.ZodLiteral<null>;
+/**
+ * DeleteLayerResponse 的推断类型
+ */
+type DeleteLayerResponse = z.infer<typeof DeleteLayerResponseSchema>;
+/**
+ * 端点参数契约：删除图层
+ */
+type DeleteLayerArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof LayerIdParamsSchema>;
+};
+//#endregion
+//#region src/domains/layer/layer.client.d.ts
+/**
+ * layer 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createLayerEndpoints(transport: ApiTransport): {
+  /**
+   * 创建图层
+   */
+  createLayer: (args: CreateLayerArgs) => Promise<{
+    id: string;
+    graphId: string;
+    name: string;
+    layerType: "custom" | "organization" | "person" | "society";
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 获取单个图层
+   */
+  getLayer: (args: GetLayerArgs) => Promise<{
+    id: string;
+    graphId: string;
+    name: string;
+    layerType: "custom" | "organization" | "person" | "society";
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+  } | null>;
+  /**
+   * 获取图层列表
+   */
+  listLayers: (args: ListLayersArgs) => Promise<{
+    items: {
+      id: string;
+      graphId: string;
+      name: string;
+      layerType: "custom" | "organization" | "person" | "society";
+      description?: string | undefined;
+      metadata?: Record<string, unknown> | undefined;
+      tenantId?: string | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    total: number;
+    page: number;
+    pageSize: number;
+  }>;
+  /**
+   * 更新图层
+   */
+  updateLayer: (args: UpdateLayerArgs) => Promise<{
+    id: string;
+    graphId: string;
+    name: string;
+    layerType: "custom" | "organization" | "person" | "society";
+    description?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+  }>;
+  /**
+   * 删除图层
+   */
+  deleteLayer: (args: DeleteLayerArgs) => Promise<null>;
+};
+//#endregion
+//#region src/domains/layer-node/layer-node.dto.d.ts
+/**
+ * 域公共数据契约：LayerNode
+ *
+ * 记录节点与图层的归属关系
+ */
+declare const LayerNodeSchema: z.ZodObject<{
+  id: z.ZodString;
+  layerId: z.ZodString;
+  nodeId: z.ZodString;
+  graphId: z.ZodString;
+  createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * LayerNode 的推断类型
+ */
+type LayerNode = z.infer<typeof LayerNodeSchema>;
+//#endregion
+//#region src/domains/layer-node/layer-node.schema.d.ts
+/**
+ * 图层归属路径参数契约，图层子资源路由共用
+ */
+declare const LayerScopedParamsSchema: z.ZodObject<{
+  layerId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 节点出层路径参数契约，携带图层与节点双参数
+ */
+declare const LayerNodeParamsSchema: z.ZodObject<{
+  layerId: z.ZodString;
+  nodeId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 路由常量：POST /api/layers/:layerId/nodes
+ */
+declare const AddNodeToLayerRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/layers/:layerId/nodes';
+  readonly paramNames: readonly ['layerId'];
+};
+/**
+ * 请求 schema：请求体，POST /api/layers/:layerId/nodes
+ */
+declare const AddNodeToLayerBodySchema: z.ZodObject<{
+  layerId: z.ZodString;
+  nodeId: z.ZodString;
+  graphId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * AddNodeToLayerBody 的推断类型
+ */
+type AddNodeToLayerBody = z.infer<typeof AddNodeToLayerBodySchema>;
+/**
+ * 响应 schema，POST /api/layers/:layerId/nodes
+ *
+ * 端口入层成功返回图层节点归属实体
+ */
+declare const AddNodeToLayerResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  layerId: z.ZodString;
+  nodeId: z.ZodString;
+  graphId: z.ZodString;
+  createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * AddNodeToLayerResponse 的推断类型
+ */
+type AddNodeToLayerResponse = z.infer<typeof AddNodeToLayerResponseSchema>;
+/**
+ * 端点参数契约：将节点加入图层
+ */
+type AddNodeToLayerArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof LayerScopedParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: AddNodeToLayerBody;
+};
+/**
+ * 路由常量：DELETE /api/layers/:layerId/nodes/:nodeId
+ */
+declare const RemoveNodeFromLayerRoute: {
+  readonly method: 'DELETE';
+  readonly path: '/api/layers/:layerId/nodes/:nodeId';
+  readonly paramNames: readonly ['layerId', 'nodeId'];
+};
+/**
+ * 响应 schema，DELETE /api/layers/:layerId/nodes/:nodeId
+ *
+ * 端口出层成功路径返回 void，传输层将空体归一为 null
+ */
+declare const RemoveNodeFromLayerResponseSchema: z.ZodLiteral<null>;
+/**
+ * RemoveNodeFromLayerResponse 的推断类型
+ */
+type RemoveNodeFromLayerResponse = z.infer<typeof RemoveNodeFromLayerResponseSchema>;
+/**
+ * 端点参数契约：将节点移出图层
+ */
+type RemoveNodeFromLayerArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof LayerNodeParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/layers/:layerId/nodes
+ */
+declare const GetLayerNodesRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/layers/:layerId/nodes';
+  readonly paramNames: readonly ['layerId'];
+};
+/**
+ * 响应 schema，GET /api/layers/:layerId/nodes
+ *
+ * 端口按裸数组返回图层节点归属列表
+ */
+declare const GetLayerNodesResponseSchema: z.ZodArray<z.ZodObject<{
+  id: z.ZodString;
+  layerId: z.ZodString;
+  nodeId: z.ZodString;
+  graphId: z.ZodString;
+  createdAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetLayerNodesResponse 的推断类型
+ */
+type GetLayerNodesResponse = z.infer<typeof GetLayerNodesResponseSchema>;
+/**
+ * 端点参数契约：获取图层节点列表
+ */
+type GetLayerNodesArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof LayerScopedParamsSchema>;
+};
+//#endregion
+//#region src/domains/layer-node/layer-node.client.d.ts
+/**
+ * layer-node 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createLayerNodeEndpoints(transport: ApiTransport): {
+  /**
+   * 将节点加入图层
+   */
+  addNodeToLayer: (args: AddNodeToLayerArgs) => Promise<{
+    id: string;
+    layerId: string;
+    nodeId: string;
+    graphId: string;
+    createdAt: string;
+  }>;
+  /**
+   * 将节点移出图层
+   */
+  removeNodeFromLayer: (args: RemoveNodeFromLayerArgs) => Promise<null>;
+  /**
+   * 获取图层节点列表
+   */
+  getLayerNodes: (args: GetLayerNodesArgs) => Promise<{
+    id: string;
+    layerId: string;
+    nodeId: string;
+    graphId: string;
+    createdAt: string;
+  }[]>;
+};
+//#endregion
+//#region src/domains/layer-relation/layer-relation.dto.d.ts
+/**
+ * 域公共数据契约：LayerRelation
+ *
+ * 连接源图层与目标图层的层间有向关系
+ */
+declare const LayerRelationSchema: z.ZodObject<{
+  id: z.ZodString;
+  sourceLayerId: z.ZodString;
+  targetLayerId: z.ZodString;
+  relationType: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * LayerRelation 的推断类型
+ */
+type LayerRelation = z.infer<typeof LayerRelationSchema>;
+//#endregion
+//#region src/domains/layer-relation/layer-relation.schema.d.ts
+/**
+ * 层间关系标识路径参数契约
+ */
+declare const LayerRelationIdParamsSchema: z.ZodObject<{
+  relationId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 路由常量：POST /api/layers/relations
+ */
+declare const LinkLayersRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/layers/relations';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：请求体，POST /api/layers/relations
+ */
+declare const LinkLayersBodySchema: z.ZodObject<{
+  sourceLayerId: z.ZodString;
+  targetLayerId: z.ZodString;
+  relationType: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * LinkLayersBody 的推断类型
+ */
+type LinkLayersBody = z.infer<typeof LinkLayersBodySchema>;
+/**
+ * 响应 schema，POST /api/layers/relations
+ */
+declare const LinkLayersResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  sourceLayerId: z.ZodString;
+  targetLayerId: z.ZodString;
+  relationType: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * LinkLayersResponse 的推断类型
+ */
+type LinkLayersResponse = z.infer<typeof LinkLayersResponseSchema>;
+/**
+ * 端点参数契约：建立层间关系
+ */
+type LinkLayersArgs = {
+  /**
+   * 请求体
+   */
+  readonly body?: LinkLayersBody;
+};
+/**
+ * 路由常量：DELETE /api/layers/relations/:relationId
+ */
+declare const UnlinkLayersRoute: {
+  readonly method: 'DELETE';
+  readonly path: '/api/layers/relations/:relationId';
+  readonly paramNames: readonly ['relationId'];
+};
+/**
+ * 响应 schema，DELETE /api/layers/relations/:relationId
+ *
+ * 端口解除成功路径返回 void，传输层将空体归一为 null
+ */
+declare const UnlinkLayersResponseSchema: z.ZodLiteral<null>;
+/**
+ * UnlinkLayersResponse 的推断类型
+ */
+type UnlinkLayersResponse = z.infer<typeof UnlinkLayersResponseSchema>;
+/**
+ * 端点参数契约：解除层间关系
+ */
+type UnlinkLayersArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof LayerRelationIdParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/layers/relations
+ */
+declare const GetLayerRelationsRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/layers/relations';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：查询参数，GET /api/layers/relations
+ *
+ * 服务端按源图层或目标图层之一查询，两者均缺省时返回 400
+ */
+declare const GetLayerRelationsQuerySchema: z.ZodObject<{
+  sourceLayerId: z.ZodOptional<z.ZodString>;
+  targetLayerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * GetLayerRelationsQuery 的推断类型
+ */
+type GetLayerRelationsQuery = z.infer<typeof GetLayerRelationsQuerySchema>;
+/**
+ * 响应 schema，GET /api/layers/relations
+ *
+ * 端口按裸数组返回层间关系列表
+ */
+declare const GetLayerRelationsResponseSchema: z.ZodArray<z.ZodObject<{
+  id: z.ZodString;
+  sourceLayerId: z.ZodString;
+  targetLayerId: z.ZodString;
+  relationType: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetLayerRelationsResponse 的推断类型
+ */
+type GetLayerRelationsResponse = z.infer<typeof GetLayerRelationsResponseSchema>;
+/**
+ * 端点参数契约：获取层间关系列表
+ */
+type GetLayerRelationsArgs = {
+  /**
+   * 查询参数
+   */
+  readonly query?: GetLayerRelationsQuery;
+};
+//#endregion
+//#region src/domains/layer-relation/layer-relation.client.d.ts
+/**
+ * layer-relation 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createLayerRelationEndpoints(transport: ApiTransport): {
+  /**
+   * 建立层间关系
+   */
+  linkLayers: (args: LinkLayersArgs) => Promise<{
+    id: string;
+    sourceLayerId: string;
+    targetLayerId: string;
+    relationType: string;
+    description?: string | undefined;
+    createdAt: string;
+  }>;
+  /**
+   * 解除层间关系
+   */
+  unlinkLayers: (args: UnlinkLayersArgs) => Promise<null>;
+  /**
+   * 获取层间关系列表
+   */
+  getLayerRelations: (args: GetLayerRelationsArgs) => Promise<{
+    id: string;
+    sourceLayerId: string;
+    targetLayerId: string;
+    relationType: string;
+    description?: string | undefined;
+    createdAt: string;
+  }[]>;
+};
+//#endregion
+//#region src/domains/layer-cross/layer-cross.dto.d.ts
+/**
+ * 域公共数据契约：CrossLayerResult
+ *
+ * 端口聚合返回图层、层间关系与图层节点三键
+ */
+declare const CrossLayerResultSchema: z.ZodObject<{
+  layers: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    name: z.ZodString;
+    layerType: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  relations: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sourceLayerId: z.ZodString;
+    targetLayerId: z.ZodString;
+    relationType: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+  }, z.core.$strip>>;
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    layerId: z.ZodString;
+    nodeId: z.ZodString;
+    graphId: z.ZodString;
+    createdAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * CrossLayerResult 的推断类型
+ */
+type CrossLayerResult = z.infer<typeof CrossLayerResultSchema>;
+//#endregion
+//#region src/domains/layer-cross/layer-cross.schema.d.ts
+/**
+ * 路由常量：POST /api/layers/cross/find
+ */
+declare const FindCrossLayerRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/layers/cross/find';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：请求体，POST /api/layers/cross/find
+ *
+ * 服务端实收图谱标识与图层标识列表
+ */
+declare const FindCrossLayerBodySchema: z.ZodObject<{
+  graphId: z.ZodString;
+  layerIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * FindCrossLayerBody 的推断类型
+ */
+type FindCrossLayerBody = z.infer<typeof FindCrossLayerBodySchema>;
+/**
+ * 响应 schema，POST /api/layers/cross/find
+ */
+declare const FindCrossLayerResponseSchema: z.ZodObject<{
+  layers: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    graphId: z.ZodString;
+    name: z.ZodString;
+    layerType: z.ZodEnum<{
+      custom: "custom";
+      organization: "organization";
+      person: "person";
+      society: "society";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+  }, z.core.$strip>>;
+  relations: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sourceLayerId: z.ZodString;
+    targetLayerId: z.ZodString;
+    relationType: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+  }, z.core.$strip>>;
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    layerId: z.ZodString;
+    nodeId: z.ZodString;
+    graphId: z.ZodString;
+    createdAt: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * FindCrossLayerResponse 的推断类型
+ */
+type FindCrossLayerResponse = z.infer<typeof FindCrossLayerResponseSchema>;
+/**
+ * 端点参数契约：跨层查找
+ */
+type FindCrossLayerArgs = {
+  /**
+   * 请求体
+   */
+  readonly body?: FindCrossLayerBody;
+};
+//#endregion
+//#region src/domains/layer-cross/layer-cross.client.d.ts
+/**
+ * layer-cross 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createLayerCrossEndpoints(transport: ApiTransport): {
+  /**
+   * 跨层查找
+   */
+  findCrossLayer: (args: FindCrossLayerArgs) => Promise<{
+    layers: {
+      id: string;
+      graphId: string;
+      name: string;
+      layerType: "custom" | "organization" | "person" | "society";
+      description?: string | undefined;
+      metadata?: Record<string, unknown> | undefined;
+      tenantId?: string | undefined;
+      createdAt: string;
+      updatedAt: string;
+    }[];
+    relations: {
+      id: string;
+      sourceLayerId: string;
+      targetLayerId: string;
+      relationType: string;
+      description?: string | undefined;
+      createdAt: string;
+    }[];
+    nodes: {
+      id: string;
+      layerId: string;
+      nodeId: string;
+      graphId: string;
+      createdAt: string;
+    }[];
+  }>;
+};
+//#endregion
+//#region src/domains/merge/merge.dto.d.ts
+/**
+ * 域公共枚举定义：MergeStrategy
+ */
+declare const MergeStrategySchema: z.ZodEnum<{
+  auto: "auto";
+  exact_match: "exact_match";
+  fuzzy_match: "fuzzy_match";
+  manual: "manual";
+}>;
+/**
+ * MergeStrategy 的推断类型
+ */
+type MergeStrategy = z.infer<typeof MergeStrategySchema>;
+/**
+ * 域公共枚举常量：MergeStrategy
+ */
+declare const MergeStrategy: {
+  readonly exact_match: 'exact_match';
+  readonly fuzzy_match: 'fuzzy_match';
+  readonly manual: 'manual';
+  readonly auto: 'auto';
+};
+/**
+ * 域公共枚举定义：ConflictResolution
+ */
+declare const ConflictResolutionSchema: z.ZodEnum<{
+  keep_first: "keep_first";
+  keep_last: "keep_last";
+  merge: "merge";
+  skip: "skip";
+}>;
+/**
+ * ConflictResolution 的推断类型
+ */
+type ConflictResolution = z.infer<typeof ConflictResolutionSchema>;
+/**
+ * 域公共枚举常量：ConflictResolution
+ */
+declare const ConflictResolution: {
+  readonly keep_first: 'keep_first';
+  readonly keep_last: 'keep_last';
+  readonly merge: 'merge';
+  readonly skip: 'skip';
+};
+/**
+ * 域公共枚举定义：MergeTaskStatus
+ */
+declare const MergeTaskStatusSchema: z.ZodEnum<{
+  completed: "completed";
+  failed: "failed";
+  pending: "pending";
+  running: "running";
+}>;
+/**
+ * MergeTaskStatus 的推断类型
+ */
+type MergeTaskStatus = z.infer<typeof MergeTaskStatusSchema>;
+/**
+ * 域公共枚举常量：MergeTaskStatus
+ */
+declare const MergeTaskStatus: {
+  readonly pending: 'pending';
+  readonly running: 'running';
+  readonly completed: 'completed';
+  readonly failed: 'failed';
+};
+/**
+ * 域公共数据契约：MergeStatistics
+ *
+ * 记录合并过程中节点与边的处理数量以及冲突与解决情况
+ */
+declare const MergeStatisticsSchema: z.ZodObject<{
+  totalNodes: z.ZodInt;
+  mergedNodes: z.ZodInt;
+  totalEdges: z.ZodInt;
+  mergedEdges: z.ZodInt;
+  conflicts: z.ZodInt;
+  resolutions: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * MergeStatistics 的推断类型
+ */
+type MergeStatistics = z.infer<typeof MergeStatisticsSchema>;
+/**
+ * 域公共数据契约：MergeTask
+ */
+declare const MergeTaskSchema: z.ZodObject<{
+  id: z.ZodString;
+  sourceGraphIds: z.ZodArray<z.ZodString>;
+  targetGraphId: z.ZodString;
+  strategy: z.ZodEnum<{
+    auto: "auto";
+    exact_match: "exact_match";
+    fuzzy_match: "fuzzy_match";
+    manual: "manual";
+  }>;
+  conflictResolution: z.ZodEnum<{
+    keep_first: "keep_first";
+    keep_last: "keep_last";
+    merge: "merge";
+    skip: "skip";
+  }>;
+  status: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+  }>;
+  statistics: z.ZodOptional<z.ZodObject<{
+    totalNodes: z.ZodInt;
+    mergedNodes: z.ZodInt;
+    totalEdges: z.ZodInt;
+    mergedEdges: z.ZodInt;
+    conflicts: z.ZodInt;
+    resolutions: z.ZodInt;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+  completedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * MergeTask 的推断类型
+ */
+type MergeTask = z.infer<typeof MergeTaskSchema>;
+/**
+ * 域公共数据契约：MergeTaskListData
+ *
+ * 合并任务列表四键分页面
+ */
+declare const MergeTaskListDataSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sourceGraphIds: z.ZodArray<z.ZodString>;
+    targetGraphId: z.ZodString;
+    strategy: z.ZodEnum<{
+      auto: "auto";
+      exact_match: "exact_match";
+      fuzzy_match: "fuzzy_match";
+      manual: "manual";
+    }>;
+    conflictResolution: z.ZodEnum<{
+      keep_first: "keep_first";
+      keep_last: "keep_last";
+      merge: "merge";
+      skip: "skip";
+    }>;
+    status: z.ZodEnum<{
+      completed: "completed";
+      failed: "failed";
+      pending: "pending";
+      running: "running";
+    }>;
+    statistics: z.ZodOptional<z.ZodObject<{
+      totalNodes: z.ZodInt;
+      mergedNodes: z.ZodInt;
+      totalEdges: z.ZodInt;
+      mergedEdges: z.ZodInt;
+      conflicts: z.ZodInt;
+      resolutions: z.ZodInt;
+    }, z.core.$strip>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * MergeTaskListData 的推断类型
+ */
+type MergeTaskListData = z.infer<typeof MergeTaskListDataSchema>;
+//#endregion
+//#region src/domains/merge/merge.schema.d.ts
+/**
+ * 合并任务标识路径参数契约，合并任务路由共用
+ */
+declare const MergeTaskIdParamsSchema: z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>;
+/**
+ * 路由常量：POST /api/merge/tasks
+ */
+declare const CreateMergeTaskRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/merge/tasks';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：请求体，POST /api/merge/tasks
+ */
+declare const CreateMergeTaskBodySchema: z.ZodObject<{
+  sourceGraphIds: z.ZodArray<z.ZodString>;
+  targetGraphId: z.ZodString;
+  strategy: z.ZodEnum<{
+    auto: "auto";
+    exact_match: "exact_match";
+    fuzzy_match: "fuzzy_match";
+    manual: "manual";
+  }>;
+  conflictResolution: z.ZodEnum<{
+    keep_first: "keep_first";
+    keep_last: "keep_last";
+    merge: "merge";
+    skip: "skip";
+  }>;
+  tenantId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * CreateMergeTaskBody 的推断类型
+ */
+type CreateMergeTaskBody = z.infer<typeof CreateMergeTaskBodySchema>;
+/**
+ * 响应 schema，POST /api/merge/tasks
+ */
+declare const CreateMergeTaskResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  sourceGraphIds: z.ZodArray<z.ZodString>;
+  targetGraphId: z.ZodString;
+  strategy: z.ZodEnum<{
+    auto: "auto";
+    exact_match: "exact_match";
+    fuzzy_match: "fuzzy_match";
+    manual: "manual";
+  }>;
+  conflictResolution: z.ZodEnum<{
+    keep_first: "keep_first";
+    keep_last: "keep_last";
+    merge: "merge";
+    skip: "skip";
+  }>;
+  status: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+  }>;
+  statistics: z.ZodOptional<z.ZodObject<{
+    totalNodes: z.ZodInt;
+    mergedNodes: z.ZodInt;
+    totalEdges: z.ZodInt;
+    mergedEdges: z.ZodInt;
+    conflicts: z.ZodInt;
+    resolutions: z.ZodInt;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+  completedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * CreateMergeTaskResponse 的推断类型
+ */
+type CreateMergeTaskResponse = z.infer<typeof CreateMergeTaskResponseSchema>;
+/**
+ * 端点参数契约：创建合并任务
+ */
+type CreateMergeTaskArgs = {
+  /**
+   * 请求体
+   */
+  readonly body?: CreateMergeTaskBody;
+};
+/**
+ * 路由常量：GET /api/merge/tasks/:id
+ */
+declare const GetMergeTaskRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/merge/tasks/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 响应 schema，GET /api/merge/tasks/:id
+ *
+ * 端口详情查询可空，任务不存在时返回 null
+ */
+declare const GetMergeTaskResponseSchema: z.ZodNullable<z.ZodObject<{
+  id: z.ZodString;
+  sourceGraphIds: z.ZodArray<z.ZodString>;
+  targetGraphId: z.ZodString;
+  strategy: z.ZodEnum<{
+    auto: "auto";
+    exact_match: "exact_match";
+    fuzzy_match: "fuzzy_match";
+    manual: "manual";
+  }>;
+  conflictResolution: z.ZodEnum<{
+    keep_first: "keep_first";
+    keep_last: "keep_last";
+    merge: "merge";
+    skip: "skip";
+  }>;
+  status: z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+  }>;
+  statistics: z.ZodOptional<z.ZodObject<{
+    totalNodes: z.ZodInt;
+    mergedNodes: z.ZodInt;
+    totalEdges: z.ZodInt;
+    mergedEdges: z.ZodInt;
+    conflicts: z.ZodInt;
+    resolutions: z.ZodInt;
+  }, z.core.$strip>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+  completedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+/**
+ * GetMergeTaskResponse 的推断类型
+ */
+type GetMergeTaskResponse = z.infer<typeof GetMergeTaskResponseSchema>;
+/**
+ * 端点参数契约：获取单个合并任务
+ */
+type GetMergeTaskArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof MergeTaskIdParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/merge/tasks
+ */
+declare const ListMergeTasksRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/merge/tasks';
+  readonly paramNames: readonly [];
+};
+/**
+ * 请求 schema：查询参数，GET /api/merge/tasks
+ */
+declare const ListMergeTasksQuerySchema: z.ZodObject<{
+  status: z.ZodOptional<z.ZodEnum<{
+    completed: "completed";
+    failed: "failed";
+    pending: "pending";
+    running: "running";
+  }>>;
+  strategy: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    exact_match: "exact_match";
+    fuzzy_match: "fuzzy_match";
+    manual: "manual";
+  }>>;
+  tenantId: z.ZodOptional<z.ZodString>;
+  page: z.ZodOptional<z.ZodInt>;
+  pageSize: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * ListMergeTasksQuery 的推断类型
+ */
+type ListMergeTasksQuery = z.infer<typeof ListMergeTasksQuerySchema>;
+/**
+ * 响应 schema，GET /api/merge/tasks
+ */
+declare const ListMergeTasksResponseSchema: z.ZodObject<{
+  items: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sourceGraphIds: z.ZodArray<z.ZodString>;
+    targetGraphId: z.ZodString;
+    strategy: z.ZodEnum<{
+      auto: "auto";
+      exact_match: "exact_match";
+      fuzzy_match: "fuzzy_match";
+      manual: "manual";
+    }>;
+    conflictResolution: z.ZodEnum<{
+      keep_first: "keep_first";
+      keep_last: "keep_last";
+      merge: "merge";
+      skip: "skip";
+    }>;
+    status: z.ZodEnum<{
+      completed: "completed";
+      failed: "failed";
+      pending: "pending";
+      running: "running";
+    }>;
+    statistics: z.ZodOptional<z.ZodObject<{
+      totalNodes: z.ZodInt;
+      mergedNodes: z.ZodInt;
+      totalEdges: z.ZodInt;
+      mergedEdges: z.ZodInt;
+      conflicts: z.ZodInt;
+      resolutions: z.ZodInt;
+    }, z.core.$strip>>;
+    tenantId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  total: z.ZodInt;
+  page: z.ZodInt;
+  pageSize: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * ListMergeTasksResponse 的推断类型
+ */
+type ListMergeTasksResponse = z.infer<typeof ListMergeTasksResponseSchema>;
+/**
+ * 端点参数契约：获取合并任务列表
+ */
+type ListMergeTasksArgs = {
+  /**
+   * 查询参数
+   */
+  readonly query?: ListMergeTasksQuery;
+};
+/**
+ * 路由常量：DELETE /api/merge/tasks/:id
+ */
+declare const DeleteMergeTaskRoute: {
+  readonly method: 'DELETE';
+  readonly path: '/api/merge/tasks/:id';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 响应 schema，DELETE /api/merge/tasks/:id
+ *
+ * 端口删除成功路径返回 void，传输层将空体归一为 null
+ */
+declare const DeleteMergeTaskResponseSchema: z.ZodLiteral<null>;
+/**
+ * DeleteMergeTaskResponse 的推断类型
+ */
+type DeleteMergeTaskResponse = z.infer<typeof DeleteMergeTaskResponseSchema>;
+/**
+ * 端点参数契约：删除合并任务
+ */
+type DeleteMergeTaskArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof MergeTaskIdParamsSchema>;
+};
+//#endregion
+//#region src/domains/merge/merge.client.d.ts
+/**
+ * merge 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createMergeEndpoints(transport: ApiTransport): {
+  /**
+   * 创建合并任务
+   */
+  createMergeTask: (args: CreateMergeTaskArgs) => Promise<{
+    id: string;
+    sourceGraphIds: string[];
+    targetGraphId: string;
+    strategy: "auto" | "exact_match" | "fuzzy_match" | "manual";
+    conflictResolution: "keep_first" | "keep_last" | "merge" | "skip";
+    status: "completed" | "failed" | "pending" | "running";
+    statistics?: {
+      totalNodes: number;
+      mergedNodes: number;
+      totalEdges: number;
+      mergedEdges: number;
+      conflicts: number;
+      resolutions: number;
+    } | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string | undefined;
+  }>;
+  /**
+   * 获取单个合并任务
+   */
+  getMergeTask: (args: GetMergeTaskArgs) => Promise<{
+    id: string;
+    sourceGraphIds: string[];
+    targetGraphId: string;
+    strategy: "auto" | "exact_match" | "fuzzy_match" | "manual";
+    conflictResolution: "keep_first" | "keep_last" | "merge" | "skip";
+    status: "completed" | "failed" | "pending" | "running";
+    statistics?: {
+      totalNodes: number;
+      mergedNodes: number;
+      totalEdges: number;
+      mergedEdges: number;
+      conflicts: number;
+      resolutions: number;
+    } | undefined;
+    tenantId?: string | undefined;
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string | undefined;
+  } | null>;
+  /**
+   * 获取合并任务列表
+   */
+  listMergeTasks: (args: ListMergeTasksArgs) => Promise<{
+    items: {
+      id: string;
+      sourceGraphIds: string[];
+      targetGraphId: string;
+      strategy: "auto" | "exact_match" | "fuzzy_match" | "manual";
+      conflictResolution: "keep_first" | "keep_last" | "merge" | "skip";
+      status: "completed" | "failed" | "pending" | "running";
+      statistics?: {
+        totalNodes: number;
+        mergedNodes: number;
+        totalEdges: number;
+        mergedEdges: number;
+        conflicts: number;
+        resolutions: number;
+      } | undefined;
+      tenantId?: string | undefined;
+      createdAt: string;
+      updatedAt: string;
+      completedAt?: string | undefined;
+    }[];
+    total: number;
+    page: number;
+    pageSize: number;
+  }>;
+  /**
+   * 删除合并任务
+   */
+  deleteMergeTask: (args: DeleteMergeTaskArgs) => Promise<null>;
+};
+//#endregion
+//#region src/domains/merge-execution/merge-execution.dto.d.ts
+/**
+ * 域公共枚举定义：MergeConflictType
+ */
+declare const MergeConflictTypeSchema: z.ZodEnum<{
+  ambiguity: "ambiguity";
+  contradiction: "contradiction";
+  duplicate: "duplicate";
+}>;
+/**
+ * MergeConflictType 的推断类型
+ */
+type MergeConflictType = z.infer<typeof MergeConflictTypeSchema>;
+/**
+ * 域公共枚举常量：MergeConflictType
+ */
+declare const MergeConflictType: {
+  readonly duplicate: 'duplicate';
+  readonly contradiction: 'contradiction';
+  readonly ambiguity: 'ambiguity';
+};
+/**
+ * 域公共枚举定义：EntityMatchType
+ */
+declare const EntityMatchTypeSchema: z.ZodEnum<{
+  exact: "exact";
+  fuzzy: "fuzzy";
+  manual: "manual";
+}>;
+/**
+ * EntityMatchType 的推断类型
+ */
+type EntityMatchType = z.infer<typeof EntityMatchTypeSchema>;
+/**
+ * 域公共枚举常量：EntityMatchType
+ */
+declare const EntityMatchType: {
+  readonly exact: 'exact';
+  readonly fuzzy: 'fuzzy';
+  readonly manual: 'manual';
+};
+/**
+ * 域公共数据契约：MergeConflict
+ *
+ * 记录合并过程中检测到的冲突及其解决情况
+ */
+declare const MergeConflictSchema: z.ZodObject<{
+  id: z.ZodString;
+  sourceNodeId: z.ZodString;
+  targetNodeId: z.ZodString;
+  nodeLabel: z.ZodString;
+  conflictType: z.ZodEnum<{
+    ambiguity: "ambiguity";
+    contradiction: "contradiction";
+    duplicate: "duplicate";
+  }>;
+  resolution: z.ZodOptional<z.ZodEnum<{
+    keep_first: "keep_first";
+    keep_last: "keep_last";
+    merge: "merge";
+    skip: "skip";
+  }>>;
+  resolvedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * MergeConflict 的推断类型
+ */
+type MergeConflict = z.infer<typeof MergeConflictSchema>;
+/**
+ * 域公共数据契约：MergeResult
+ *
+ * 一次合并任务执行后的完整产出物，含统计信息与冲突列表
+ */
+declare const MergeResultSchema: z.ZodObject<{
+  id: z.ZodString;
+  taskId: z.ZodString;
+  targetGraphId: z.ZodString;
+  statistics: z.ZodObject<{
+    totalNodes: z.ZodInt;
+    mergedNodes: z.ZodInt;
+    totalEdges: z.ZodInt;
+    mergedEdges: z.ZodInt;
+    conflicts: z.ZodInt;
+    resolutions: z.ZodInt;
+  }, z.core.$strip>;
+  conflicts: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sourceNodeId: z.ZodString;
+    targetNodeId: z.ZodString;
+    nodeLabel: z.ZodString;
+    conflictType: z.ZodEnum<{
+      ambiguity: "ambiguity";
+      contradiction: "contradiction";
+      duplicate: "duplicate";
+    }>;
+    resolution: z.ZodOptional<z.ZodEnum<{
+      keep_first: "keep_first";
+      keep_last: "keep_last";
+      merge: "merge";
+      skip: "skip";
+    }>>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * MergeResult 的推断类型
+ */
+type MergeResult = z.infer<typeof MergeResultSchema>;
+/**
+ * 域公共数据契约：EntityResolution
+ *
+ * 记录一组源节点合并为一个目标节点的消解结果
+ */
+declare const EntityResolutionSchema: z.ZodObject<{
+  id: z.ZodString;
+  taskId: z.ZodString;
+  sourceNodeIds: z.ZodArray<z.ZodString>;
+  targetNodeId: z.ZodString;
+  matchType: z.ZodEnum<{
+    exact: "exact";
+    fuzzy: "fuzzy";
+    manual: "manual";
+  }>;
+  confidence: z.ZodNumber;
+  createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * EntityResolution 的推断类型
+ */
+type EntityResolution = z.infer<typeof EntityResolutionSchema>;
+//#endregion
+//#region src/domains/merge-execution/merge-execution.schema.d.ts
+/**
+ * 路由常量：POST /api/merge/tasks/:id/execute
+ */
+declare const ExecuteMergeRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/merge/tasks/:id/execute';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 响应 schema，POST /api/merge/tasks/:id/execute
+ *
+ * 端口执行合并返回完整合并结果实体
+ */
+declare const ExecuteMergeResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  taskId: z.ZodString;
+  targetGraphId: z.ZodString;
+  statistics: z.ZodObject<{
+    totalNodes: z.ZodInt;
+    mergedNodes: z.ZodInt;
+    totalEdges: z.ZodInt;
+    mergedEdges: z.ZodInt;
+    conflicts: z.ZodInt;
+    resolutions: z.ZodInt;
+  }, z.core.$strip>;
+  conflicts: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sourceNodeId: z.ZodString;
+    targetNodeId: z.ZodString;
+    nodeLabel: z.ZodString;
+    conflictType: z.ZodEnum<{
+      ambiguity: "ambiguity";
+      contradiction: "contradiction";
+      duplicate: "duplicate";
+    }>;
+    resolution: z.ZodOptional<z.ZodEnum<{
+      keep_first: "keep_first";
+      keep_last: "keep_last";
+      merge: "merge";
+      skip: "skip";
+    }>>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  createdAt: z.ZodString;
+}, z.core.$strip>;
+/**
+ * ExecuteMergeResponse 的推断类型
+ */
+type ExecuteMergeResponse = z.infer<typeof ExecuteMergeResponseSchema>;
+/**
+ * 端点参数契约：执行合并任务
+ */
+type ExecuteMergeArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof MergeTaskIdParamsSchema>;
+};
+/**
+ * 路由常量：POST /api/merge/tasks/:id/conflicts/resolve
+ */
+declare const ResolveConflictRoute: {
+  readonly method: 'POST';
+  readonly path: '/api/merge/tasks/:id/conflicts/resolve';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 请求 schema：请求体，POST /api/merge/tasks/:id/conflicts/resolve
+ */
+declare const ResolveConflictBodySchema: z.ZodObject<{
+  conflictId: z.ZodString;
+  resolution: z.ZodEnum<{
+    keep_first: "keep_first";
+    keep_last: "keep_last";
+    merge: "merge";
+    skip: "skip";
+  }>;
+}, z.core.$strip>;
+/**
+ * ResolveConflictBody 的推断类型
+ */
+type ResolveConflictBody = z.infer<typeof ResolveConflictBodySchema>;
+/**
+ * 响应 schema，POST /api/merge/tasks/:id/conflicts/resolve
+ *
+ * 端口解决冲突返回解决后的合并冲突对象
+ */
+declare const ResolveConflictResponseSchema: z.ZodObject<{
+  id: z.ZodString;
+  sourceNodeId: z.ZodString;
+  targetNodeId: z.ZodString;
+  nodeLabel: z.ZodString;
+  conflictType: z.ZodEnum<{
+    ambiguity: "ambiguity";
+    contradiction: "contradiction";
+    duplicate: "duplicate";
+  }>;
+  resolution: z.ZodOptional<z.ZodEnum<{
+    keep_first: "keep_first";
+    keep_last: "keep_last";
+    merge: "merge";
+    skip: "skip";
+  }>>;
+  resolvedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * ResolveConflictResponse 的推断类型
+ */
+type ResolveConflictResponse = z.infer<typeof ResolveConflictResponseSchema>;
+/**
+ * 端点参数契约：解决合并冲突
+ */
+type ResolveConflictArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof MergeTaskIdParamsSchema>;
+  /**
+   * 请求体
+   */
+  readonly body?: ResolveConflictBody;
+};
+/**
+ * 路由常量：GET /api/merge/tasks/:id/result
+ */
+declare const GetMergeResultRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/merge/tasks/:id/result';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 响应 schema，GET /api/merge/tasks/:id/result
+ *
+ * 端口结果查询可空，任务未产生结果时返回 null
+ */
+declare const GetMergeResultResponseSchema: z.ZodNullable<z.ZodObject<{
+  id: z.ZodString;
+  taskId: z.ZodString;
+  targetGraphId: z.ZodString;
+  statistics: z.ZodObject<{
+    totalNodes: z.ZodInt;
+    mergedNodes: z.ZodInt;
+    totalEdges: z.ZodInt;
+    mergedEdges: z.ZodInt;
+    conflicts: z.ZodInt;
+    resolutions: z.ZodInt;
+  }, z.core.$strip>;
+  conflicts: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    sourceNodeId: z.ZodString;
+    targetNodeId: z.ZodString;
+    nodeLabel: z.ZodString;
+    conflictType: z.ZodEnum<{
+      ambiguity: "ambiguity";
+      contradiction: "contradiction";
+      duplicate: "duplicate";
+    }>;
+    resolution: z.ZodOptional<z.ZodEnum<{
+      keep_first: "keep_first";
+      keep_last: "keep_last";
+      merge: "merge";
+      skip: "skip";
+    }>>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  createdAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetMergeResultResponse 的推断类型
+ */
+type GetMergeResultResponse = z.infer<typeof GetMergeResultResponseSchema>;
+/**
+ * 端点参数契约：获取合并结果
+ */
+type GetMergeResultArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof MergeTaskIdParamsSchema>;
+};
+/**
+ * 路由常量：GET /api/merge/tasks/:id/resolutions
+ */
+declare const GetEntityResolutionsRoute: {
+  readonly method: 'GET';
+  readonly path: '/api/merge/tasks/:id/resolutions';
+  readonly paramNames: readonly ['id'];
+};
+/**
+ * 响应 schema，GET /api/merge/tasks/:id/resolutions
+ *
+ * 端口按裸数组返回实体消解记录列表
+ */
+declare const GetEntityResolutionsResponseSchema: z.ZodArray<z.ZodObject<{
+  id: z.ZodString;
+  taskId: z.ZodString;
+  sourceNodeIds: z.ZodArray<z.ZodString>;
+  targetNodeId: z.ZodString;
+  matchType: z.ZodEnum<{
+    exact: "exact";
+    fuzzy: "fuzzy";
+    manual: "manual";
+  }>;
+  confidence: z.ZodNumber;
+  createdAt: z.ZodString;
+}, z.core.$strip>>;
+/**
+ * GetEntityResolutionsResponse 的推断类型
+ */
+type GetEntityResolutionsResponse = z.infer<typeof GetEntityResolutionsResponseSchema>;
+/**
+ * 端点参数契约：获取实体消解记录
+ */
+type GetEntityResolutionsArgs = {
+  /**
+   * 路径参数
+   */
+  readonly params: z.infer<typeof MergeTaskIdParamsSchema>;
+};
+//#endregion
+//#region src/domains/merge-execution/merge-execution.client.d.ts
+/**
+ * merge-execution 域端点工厂，注入传输实现后取得全部端点函数
+ *
+ * @param transport - 传输实现，由产品仓注入
+ * @returns 全部端点函数集合
+ */
+declare function createMergeExecutionEndpoints(transport: ApiTransport): {
+  /**
+   * 执行合并任务
+   */
+  executeMerge: (args: ExecuteMergeArgs) => Promise<{
+    id: string;
+    taskId: string;
+    targetGraphId: string;
+    statistics: {
+      totalNodes: number;
+      mergedNodes: number;
+      totalEdges: number;
+      mergedEdges: number;
+      conflicts: number;
+      resolutions: number;
+    };
+    conflicts: {
+      id: string;
+      sourceNodeId: string;
+      targetNodeId: string;
+      nodeLabel: string;
+      conflictType: "ambiguity" | "contradiction" | "duplicate";
+      resolution?: "keep_first" | "keep_last" | "merge" | "skip" | undefined;
+      resolvedAt?: string | undefined;
+    }[];
+    createdAt: string;
+  }>;
+  /**
+   * 解决合并冲突
+   */
+  resolveConflict: (args: ResolveConflictArgs) => Promise<{
+    id: string;
+    sourceNodeId: string;
+    targetNodeId: string;
+    nodeLabel: string;
+    conflictType: "ambiguity" | "contradiction" | "duplicate";
+    resolution?: "keep_first" | "keep_last" | "merge" | "skip" | undefined;
+    resolvedAt?: string | undefined;
+  }>;
+  /**
+   * 获取合并结果
+   */
+  getMergeResult: (args: GetMergeResultArgs) => Promise<{
+    id: string;
+    taskId: string;
+    targetGraphId: string;
+    statistics: {
+      totalNodes: number;
+      mergedNodes: number;
+      totalEdges: number;
+      mergedEdges: number;
+      conflicts: number;
+      resolutions: number;
+    };
+    conflicts: {
+      id: string;
+      sourceNodeId: string;
+      targetNodeId: string;
+      nodeLabel: string;
+      conflictType: "ambiguity" | "contradiction" | "duplicate";
+      resolution?: "keep_first" | "keep_last" | "merge" | "skip" | undefined;
+      resolvedAt?: string | undefined;
+    }[];
+    createdAt: string;
+  } | null>;
+  /**
+   * 获取实体消解记录
+   */
+  getEntityResolutions: (args: GetEntityResolutionsArgs) => Promise<{
+    id: string;
+    taskId: string;
+    sourceNodeIds: string[];
+    targetNodeId: string;
+    matchType: "exact" | "fuzzy" | "manual";
+    confidence: number;
+    createdAt: string;
+  }[]>;
+};
+//#endregion
+export { AddNodeToLayerArgs, AddNodeToLayerBody, AddNodeToLayerBodySchema, AddNodeToLayerResponse, AddNodeToLayerResponseSchema, AddNodeToLayerRoute, ApiContractError, ApiContractErrorDetails, ApiContractPart, ApiHttpMethod, ApiTransport, ApiTransportRequest, ConflictResolution, ConflictResolutionSchema, CreateEdgeArgs, CreateEdgeBody, CreateEdgeBodySchema, CreateEdgeResponse, CreateEdgeResponseSchema, CreateEdgeRoute, CreateGraphArgs, CreateGraphBody, CreateGraphBodySchema, CreateGraphResponse, CreateGraphResponseSchema, CreateGraphRoute, CreateLayerArgs, CreateLayerBody, CreateLayerBodySchema, CreateLayerResponse, CreateLayerResponseSchema, CreateLayerRoute, CreateMergeTaskArgs, CreateMergeTaskBody, CreateMergeTaskBodySchema, CreateMergeTaskResponse, CreateMergeTaskResponseSchema, CreateMergeTaskRoute, CreateNodeArgs, CreateNodeBody, CreateNodeBodySchema, CreateNodeResponse, CreateNodeResponseSchema, CreateNodeRoute, CrossLayerResult, CrossLayerResultSchema, DeleteEdgeArgs, DeleteEdgeResponse, DeleteEdgeResponseSchema, DeleteEdgeRoute, DeleteGraphArgs, DeleteGraphParamsSchema, DeleteGraphResponse, DeleteGraphResponseSchema, DeleteGraphRoute, DeleteLayerArgs, DeleteLayerResponse, DeleteLayerResponseSchema, DeleteLayerRoute, DeleteMergeTaskArgs, DeleteMergeTaskResponse, DeleteMergeTaskResponseSchema, DeleteMergeTaskRoute, DeleteNodeArgs, DeleteNodeResponse, DeleteNodeResponseSchema, DeleteNodeRoute, Edge, EdgeListData, EdgeListDataSchema, EdgeSchema, EdgeType, EdgeTypeSchema, EntityMatchType, EntityMatchTypeSchema, EntityResolution, EntityResolutionSchema, ExecuteMergeArgs, ExecuteMergeResponse, ExecuteMergeResponseSchema, ExecuteMergeRoute, ExportGraphBundleArgs, ExportGraphBundleParamsSchema, ExportGraphBundleResponse, ExportGraphBundleResponseSchema, ExportGraphBundleRoute, FindCrossLayerArgs, FindCrossLayerBody, FindCrossLayerBodySchema, FindCrossLayerResponse, FindCrossLayerResponseSchema, FindCrossLayerRoute, GetAncestorsArgs, GetAncestorsResponse, GetAncestorsResponseSchema, GetAncestorsRoute, GetDescendantsArgs, GetDescendantsResponse, GetDescendantsResponseSchema, GetDescendantsRoute, GetEdgeArgs, GetEdgeResponse, GetEdgeResponseSchema, GetEdgeRoute, GetEntityResolutionsArgs, GetEntityResolutionsResponse, GetEntityResolutionsResponseSchema, GetEntityResolutionsRoute, GetGraphArgs, GetGraphParamsSchema, GetGraphResponse, GetGraphResponseSchema, GetGraphRoute, GetGroupFoldArgs, GetGroupFoldQuerySchema, GetGroupFoldResponse, GetGroupFoldResponseSchema, GetGroupFoldRoute, GetLayerArgs, GetLayerNodesArgs, GetLayerNodesResponse, GetLayerNodesResponseSchema, GetLayerNodesRoute, GetLayerRelationsArgs, GetLayerRelationsQuery, GetLayerRelationsQuerySchema, GetLayerRelationsResponse, GetLayerRelationsResponseSchema, GetLayerRelationsRoute, GetLayerResponse, GetLayerResponseSchema, GetLayerRoute, GetLearningPathArgs, GetLearningPathBody, GetLearningPathBodySchema, GetLearningPathResponse, GetLearningPathResponseSchema, GetLearningPathRoute, GetMergeResultArgs, GetMergeResultResponse, GetMergeResultResponseSchema, GetMergeResultRoute, GetMergeTaskArgs, GetMergeTaskResponse, GetMergeTaskResponseSchema, GetMergeTaskRoute, GetNeighborsArgs, GetNeighborsResponse, GetNeighborsResponseSchema, GetNeighborsRoute, GetNodeArgs, GetNodeResponse, GetNodeResponseSchema, GetNodeRoute, GetSubgraphArgs, GetSubgraphBody, GetSubgraphBodySchema, GetSubgraphResponse, GetSubgraphResponseSchema, GetSubgraphRoute, GetTopologicalOrderArgs, GetTopologicalOrderQuerySchema, GetTopologicalOrderResponse, GetTopologicalOrderResponseSchema, GetTopologicalOrderRoute, GetTransitiveReductionArgs, GetTransitiveReductionBody, GetTransitiveReductionBodySchema, GetTransitiveReductionResponse, GetTransitiveReductionResponseSchema, GetTransitiveReductionRoute, Graph, GraphBundle, GraphBundleSchema, GraphKind, GraphKindSchema, GraphListData, GraphListDataSchema, GraphProfile, GraphProfileSchema, GraphQueryParamsWireSchema, GraphSchema, GraphScopedIdParamsSchema, GraphScopedParamsSchema, GraphSliceData, GraphSliceDataSchema, GroupAxisParamsSchema, GroupFoldAxis, GroupFoldAxisSchema, GroupFoldData, GroupFoldDataSchema, IdListData, IdListDataSchema, ImportGraphBundleArgs, ImportGraphBundleBody, ImportGraphBundleBodySchema, ImportGraphBundleResponse, ImportGraphBundleResponseSchema, ImportGraphBundleRoute, Layer, LayerIdParamsSchema, LayerListData, LayerListDataSchema, LayerNode, LayerNodeParamsSchema, LayerNodeSchema, LayerRelation, LayerRelationIdParamsSchema, LayerRelationSchema, LayerSchema, LayerScopedParamsSchema, LayerType, LayerTypeSchema, LinkLayersArgs, LinkLayersBody, LinkLayersBodySchema, LinkLayersResponse, LinkLayersResponseSchema, LinkLayersRoute, ListEdgesArgs, ListEdgesQuery, ListEdgesQuerySchema, ListEdgesResponse, ListEdgesResponseSchema, ListEdgesRoute, ListGraphsArgs, ListGraphsQuery, ListGraphsQuerySchema, ListGraphsResponse, ListGraphsResponseSchema, ListGraphsRoute, ListLayersArgs, ListLayersQuery, ListLayersQuerySchema, ListLayersResponse, ListLayersResponseSchema, ListLayersRoute, ListMergeTasksArgs, ListMergeTasksQuery, ListMergeTasksQuerySchema, ListMergeTasksResponse, ListMergeTasksResponseSchema, ListMergeTasksRoute, ListNodesArgs, ListNodesQuery, ListNodesQuerySchema, ListNodesResponse, ListNodesResponseSchema, ListNodesRoute, MergeConflict, MergeConflictSchema, MergeConflictType, MergeConflictTypeSchema, MergeResult, MergeResultSchema, MergeStatistics, MergeStatisticsSchema, MergeStrategy, MergeStrategySchema, MergeTask, MergeTaskIdParamsSchema, MergeTaskListData, MergeTaskListDataSchema, MergeTaskSchema, MergeTaskStatus, MergeTaskStatusSchema, NeighborsData, NeighborsDataSchema, Node, NodeListData, NodeListDataSchema, NodeSchema, NodeType, NodeTypeSchema, NullResult, NullResultSchema, RemoveNodeFromLayerArgs, RemoveNodeFromLayerResponse, RemoveNodeFromLayerResponseSchema, RemoveNodeFromLayerRoute, ResolveConflictArgs, ResolveConflictBody, ResolveConflictBodySchema, ResolveConflictResponse, ResolveConflictResponseSchema, ResolveConflictRoute, TraverseData, TraverseDataSchema, TraverseDirection, TraverseDirectionSchema, TraverseGraphArgs, TraverseGraphBody, TraverseGraphBodySchema, TraverseGraphResponse, TraverseGraphResponseSchema, TraverseGraphRoute, TraverseNode, TraverseNodeSchema, UnlinkLayersArgs, UnlinkLayersResponse, UnlinkLayersResponseSchema, UnlinkLayersRoute, UpdateEdgeArgs, UpdateEdgeBody, UpdateEdgeBodySchema, UpdateEdgeResponse, UpdateEdgeResponseSchema, UpdateEdgeRoute, UpdateGraphArgs, UpdateGraphBody, UpdateGraphBodySchema, UpdateGraphParamsSchema, UpdateGraphResponse, UpdateGraphResponseSchema, UpdateGraphRoute, UpdateLayerArgs, UpdateLayerBody, UpdateLayerBodySchema, UpdateLayerResponse, UpdateLayerResponseSchema, UpdateLayerRoute, UpdateNodeArgs, UpdateNodeBody, UpdateNodeBodySchema, UpdateNodeResponse, UpdateNodeResponseSchema, UpdateNodeRoute, buildApiPath, createGraphEdgeEndpoints, createGraphEndpoints, createGraphNodeEndpoints, createGraphQueryEndpoints, createLayerCrossEndpoints, createLayerEndpoints, createLayerNodeEndpoints, createLayerRelationEndpoints, createMergeEndpoints, createMergeExecutionEndpoints };