/**
* Generated by Kubb (https://kubb.dev/).
* Do not edit manually.
*/

import * as z from "zod";
import type { AddConversation200, AddConversationError, AddConversationMutationRequest, AddConversationMutationResponse, ApiResponseEnvelope, ConversationRole, Pagination, ConversationItem, ConversationAddRequest, ConversationAddData, ConversationQueryRequest, ConversationQueryData, ConversationDeleteRequest, ConversationDeleteData, AtomicDetail, AtomicUpdateRequest, AtomicUpdateData, AtomicDeleteRequest, AtomicDeleteData, AtomicQueryRequest, AtomicQueryData, ScenarioListRequest, ScenarioEntry, ScenarioListData, ScenarioFile, ScenarioReadRequest, ScenarioRmRequest, ScenarioWriteRequest, ScenarioWriteData, CoreFile, CoreReadRequest, CoreWriteRequest, CoreWriteData, ConversationSearchRequest, ConversationSearchHit, ConversationSearchData, AtomicSearchRequest, AtomicSearchHit, AtomicSearchData, QueryConversation200, QueryConversationError, QueryConversationMutationRequest, QueryConversationMutationResponse, SearchConversation200, SearchConversationError, SearchConversationMutationRequest, SearchConversationMutationResponse, DeleteConversation200, DeleteConversationError, DeleteConversationMutationRequest, DeleteConversationMutationResponse, UpdateAtomic200, UpdateAtomicError, UpdateAtomicMutationRequest, UpdateAtomicMutationResponse, QueryAtomic200, QueryAtomicError, QueryAtomicMutationRequest, QueryAtomicMutationResponse, SearchAtomic200, SearchAtomicError, SearchAtomicMutationRequest, SearchAtomicMutationResponse, DeleteAtomic200, DeleteAtomicError, DeleteAtomicMutationRequest, DeleteAtomicMutationResponse, LsScenario200, LsScenarioError, LsScenarioMutationRequest, LsScenarioMutationResponse, ReadScenario200, ReadScenarioError, ReadScenarioMutationRequest, ReadScenarioMutationResponse, WriteScenario200, WriteScenarioError, WriteScenarioMutationRequest, WriteScenarioMutationResponse, RmScenario200, RmScenarioError, RmScenarioMutationRequest, RmScenarioMutationResponse, ReadCore200, ReadCoreError, ReadCoreMutationRequest, ReadCoreMutationResponse, WriteCore200, WriteCoreError, WriteCoreMutationRequest, WriteCoreMutationResponse } from "./types.ts";

export const apiResponseEnvelopeSchema = z.object({
    "code": z.int().describe("`0` 表示成功；非 0 表示失败。"),
"message": z.string(),
"request_id": z.string().describe("平台生成，用于排查定位。"),
"data": z.optional(z.object({
    
    }).describe("接口特定数据，结构见各接口定义。"))
    }) as unknown as z.ZodType<ApiResponseEnvelope>

/**
 * @description 对话发言角色。
 */
export const conversationRoleSchema = z.enum(["user", "assistant", "system"]).describe("对话发言角色。") as unknown as z.ZodType<ConversationRole>

export const paginationSchema = z.object({
    "limit": z.optional(z.int().min(1).max(100).default(20).describe("单页条数。")),
"offset": z.optional(z.int().min(0).default(0).describe("偏移量，从结果集第 `offset` 条开始返回（0 表示第一页）。"))
    }) as unknown as z.ZodType<Pagination>

/**
 * @description 一条原始对话消息。发言方角色由 `role` 标识；本期不在消息级\n承载额外的身份隔离字段。\n\n`id` 为只读字段：写入入口 `POST /conversation/add` 不接受调用方\n指定 `id`（由内核生成后通过 `accepted_ids` 回传）；读取入口\n`POST /conversation/query` 必返回 `id`。本期 L0 不提供\"按 id 取\n单条详情\"的接口，`id` 主要用作内核侧追踪标识，不参与对外回链。\n
 */
export const conversationItemSchema = z.object({
    "id": z.optional(z.string().describe("L0 消息主键，全局唯一。仅出现在响应中；写入请求体内忽略\n该字段。\n")),
get "role"(){
                return conversationRoleSchema.describe("对话发言角色。")
              },
"content": z.string().min(1).max(8192).describe("消息文本内容，单条上限 8 KB。"),
"timestamp": z.optional(z.iso.datetime().describe("消息发生时间（ISO8601），缺省取服务端接收时刻。"))
    }).describe("一条原始对话消息。发言方角色由 `role` 标识；本期不在消息级\n承载额外的身份隔离字段。\n\n`id` 为只读字段：写入入口 `POST /conversation/add` 不接受调用方\n指定 `id`（由内核生成后通过 `accepted_ids` 回传）；读取入口\n`POST /conversation/query` 必返回 `id`。本期 L0 不提供\"按 id 取\n单条详情\"的接口，`id` 主要用作内核侧追踪标识，不参与对外回链。\n") as unknown as z.ZodType<ConversationItem>

export const conversationAddRequestSchema = z.object({
    "session_id": z.string().describe("业务侧会话 ID；不传则由平台按本次请求自动生成一个临时 session。"),
get "messages"(){
                return z.array(conversationItemSchema.describe("一条原始对话消息。发言方角色由 `role` 标识；本期不在消息级\n承载额外的身份隔离字段。\n\n`id` 为只读字段：写入入口 `POST /conversation/add` 不接受调用方\n指定 `id`（由内核生成后通过 `accepted_ids` 回传）；读取入口\n`POST /conversation/query` 必返回 `id`。本期 L0 不提供\"按 id 取\n单条详情\"的接口，`id` 主要用作内核侧追踪标识，不参与对外回链。\n")).min(1).max(100)
              }
    }) as unknown as z.ZodType<ConversationAddRequest>

export const conversationAddDataSchema = z.object({
    "accepted_ids": z.array(z.string()).describe("本次写入受理的 L0 消息 ID 列表，与请求 `messages` 一一对应。\n内核异步抽取出的 L1/L2/L3 沉淀结果不在此返回；调用方可在后续通过\n对应层的查询/读取/检索接口（如 `POST /atomic/query` /\n`POST /atomic/search`）观测。\n"),
"total_count": z.int()
    }) as unknown as z.ZodType<ConversationAddData>

/**
 * @description L0 消息查询请求。所有字段均**平铺**在顶层；筛选字段全部可选，\n不传等价于\"不加筛选、仅按分页返回\"。\n
 */
export const conversationQueryRequestSchema = z.object({
    "session_id": z.optional(z.string().describe("按会话过滤。")),
"limit": z.optional(z.int().min(1).max(100).default(20).describe("单页条数。")),
"offset": z.optional(z.int().min(0).default(0).describe("偏移量，从结果集第 `offset` 条开始返回（0 表示第一页）。")),
"time_start": z.optional(z.iso.datetime().describe("起始时间过滤（含端点）。")),
"time_end": z.optional(z.iso.datetime().describe("结束时间过滤（含端点）。"))
    }).describe("L0 消息查询请求。所有字段均**平铺**在顶层；筛选字段全部可选，\n不传等价于\"不加筛选、仅按分页返回\"。\n") as unknown as z.ZodType<ConversationQueryRequest>

export const conversationQueryDataSchema = z.object({
    get "messages"(){
                return z.array(conversationItemSchema.describe("一条原始对话消息。发言方角色由 `role` 标识；本期不在消息级\n承载额外的身份隔离字段。\n\n`id` 为只读字段：写入入口 `POST /conversation/add` 不接受调用方\n指定 `id`（由内核生成后通过 `accepted_ids` 回传）；读取入口\n`POST /conversation/query` 必返回 `id`。本期 L0 不提供\"按 id 取\n单条详情\"的接口，`id` 主要用作内核侧追踪标识，不参与对外回链。\n")).describe("L0 消息列表。字段命名与 `POST /conversation/add` 入参的\n`messages` 对齐；每项形状与 `ConversationItem` 一致\n（`id` / `role` / `content` / `timestamp`），其中 `id`\n为只读、读取场景必返回。\n")
              },
"total": z.int()
    }) as unknown as z.ZodType<ConversationQueryData>

/**
 * @description L0 消息批量删除请求。两种删除模式互斥，二选其一：\n\n  - **按 message id 批量删**：传 `message_ids`（非空数组），按\n    消息主键精确删除一组消息；不与 `session_id` 同时使用。\n  - **按 session 批量删**：传 `session_id`，按会话一次性删除\n    该会话下的全部消息；不与 `message_ids` 同时使用。\n\n所有字段全部缺省、或 `message_ids` 与 `session_id` 同时出现，\n均视为非法请求，返回业务错误码 `400`。本接口不带分页参数。\n
 */
export const conversationDeleteRequestSchema = z.object({
    "message_ids": z.optional(z.array(z.string()).min(1).max(100).describe("消息主键列表，单次至多 100 条。元素与 `ConversationItem.id` 同型。\n")),
"session_id": z.optional(z.string().describe("按会话过滤。"))
    }).describe("L0 消息批量删除请求。两种删除模式互斥，二选其一：\n\n  - **按 message id 批量删**：传 `message_ids`（非空数组），按\n    消息主键精确删除一组消息；不与 `session_id` 同时使用。\n  - **按 session 批量删**：传 `session_id`，按会话一次性删除\n    该会话下的全部消息；不与 `message_ids` 同时使用。\n\n所有字段全部缺省、或 `message_ids` 与 `session_id` 同时出现，\n均视为非法请求，返回业务错误码 `400`。本接口不带分页参数。\n") as unknown as z.ZodType<ConversationDeleteRequest>

export const conversationDeleteDataSchema = z.object({
    "deleted_count": z.int().describe("本次实际删除的 L0 消息条数。")
    }) as unknown as z.ZodType<ConversationDeleteData>

/**
 * @description L1 记忆笔记对外视图。一期对外暴露下列 6 个字段；笔记本身在\n内核侧还会带有 `scene_name` / `priority` / `timestamp_start` /\n`timestamp_end` / `source_message_ids` / `metadata` 等沉淀属性，\n本期 query / search 接口均不外露，后续版本如需要再按需开放。\n
 */
export const atomicDetailSchema = z.object({
    "id": z.string().describe("笔记主键，由内核生成；调用方只读。"),
"type": z.string().describe("L1 记忆类型。当前取值：`episodic` / `persona` / `instruction`；\n后续版本可能扩展。\n"),
"background": z.optional(z.string().describe("笔记产生的上下文背景信息（由调用方 / 内核沉淀策略自行\n界定语义，对外仅做存储与透传）。可通过\n`POST /atomic/update` 按 `id` 更新。\n")),
"content": z.string().describe("记忆笔记文本，调用方直接消费。"),
"created_at": z.iso.datetime().describe("笔记首次沉淀时间。"),
"updated_at": z.iso.datetime().describe("笔记最近一次更新时间，作为时间窗筛选 / 排序的事实时间。")
    }).describe("L1 记忆笔记对外视图。一期对外暴露下列 6 个字段；笔记本身在\n内核侧还会带有 `scene_name` / `priority` / `timestamp_start` /\n`timestamp_end` / `source_message_ids` / `metadata` 等沉淀属性，\n本期 query / search 接口均不外露，后续版本如需要再按需开放。\n") as unknown as z.ZodType<AtomicDetail>

/**
 * @description L1 记忆笔记按 id 更新请求。`id` 定位目标笔记；`content` 为本次\n更新后的笔记正文全量值（整体覆盖旧值，不做 diff / merge）；\n`background` **选填**——传入则整体覆盖背景字段，不传（字段\n缺省）则保持原值不变。本接口不支持\"按 id 不存在则创建\"的\nupsert 语义；若 `id` 不存在或不属于当前调用上下文，统一返回\n业务错误码 `404`。\n
 */
export const atomicUpdateRequestSchema = z.object({
    "id": z.string().describe("目标笔记主键。"),
"content": z.string().max(8192).describe("记忆笔记文本，单条上限 8 KB。"),
"background": z.optional(z.string().describe("笔记产生的上下文背景信息（由调用方自行界定语义，\n内核仅做存储 / 透传）。**选填**：字段缺省表示本次\n不更新背景；显式传入空串 `\"\"` 则代表清空背景。\n"))
    }).describe("L1 记忆笔记按 id 更新请求。`id` 定位目标笔记；`content` 为本次\n更新后的笔记正文全量值（整体覆盖旧值，不做 diff / merge）；\n`background` **选填**——传入则整体覆盖背景字段，不传（字段\n缺省）则保持原值不变。本接口不支持\"按 id 不存在则创建\"的\nupsert 语义；若 `id` 不存在或不属于当前调用上下文，统一返回\n业务错误码 `404`。\n") as unknown as z.ZodType<AtomicUpdateRequest>

/**
 * @description L1 笔记按 id 更新结果。回带笔记主键与本次更新生效时间，\n便于调用方对账。\n
 */
export const atomicUpdateDataSchema = z.object({
    "id": z.string().describe("笔记主键，回显入参 `id`。"),
"updated_at": z.iso.datetime().describe("本次更新生效时间。")
    }).describe("L1 笔记按 id 更新结果。回带笔记主键与本次更新生效时间，\n便于调用方对账。\n") as unknown as z.ZodType<AtomicUpdateData>

/**
 * @description L1 笔记按 id 批量删除请求。本期仅支持按主键精确删除，不接受\n按 `type` / 时间区间等条件批删；`ids` 缺省或为空数组视为非法\n请求，返回业务错误码 `400`。本接口不带分页参数。\n
 */
export const atomicDeleteRequestSchema = z.object({
    "ids": z.array(z.string()).min(1).max(100).describe("笔记主键列表，单次至多 100 条。")
    }).describe("L1 笔记按 id 批量删除请求。本期仅支持按主键精确删除，不接受\n按 `type` / 时间区间等条件批删；`ids` 缺省或为空数组视为非法\n请求，返回业务错误码 `400`。本接口不带分页参数。\n") as unknown as z.ZodType<AtomicDeleteRequest>

export const atomicDeleteDataSchema = z.object({
    "deleted_count": z.int().describe("本次实际删除的 L1 笔记条数。")
    }) as unknown as z.ZodType<AtomicDeleteData>

export const atomicQueryRequestSchema = z.lazy(() => paginationSchema).and(z.object({
    "type": z.optional(z.string().describe("按 L1 记忆类型过滤。当前取值：`episodic` / `persona` /\n`instruction`；后续可能扩展。\n")),
"time_start": z.optional(z.iso.datetime().describe("按 `updated_at` 起始时间过滤（含端点）。")),
"time_end": z.optional(z.iso.datetime().describe("按 `updated_at` 结束时间过滤（含端点）。"))
    })) as unknown as z.ZodType<AtomicQueryRequest>

export const atomicQueryDataSchema = z.object({
    get "items"(){
                return z.array(atomicDetailSchema.describe("L1 记忆笔记对外视图。一期对外暴露下列 6 个字段；笔记本身在\n内核侧还会带有 `scene_name` / `priority` / `timestamp_start` /\n`timestamp_end` / `source_message_ids` / `metadata` 等沉淀属性，\n本期 query / search 接口均不外露，后续版本如需要再按需开放。\n")).describe("L1 记忆笔记列表，每项为 `AtomicDetail`（一期对外仅含\n`id` / `type` / `content` / `created_at` / `updated_at`\n5 个字段，其余沉淀属性不外露）。\n")
              },
"total": z.int()
    }) as unknown as z.ZodType<AtomicQueryData>

/**
 * @description L2 场景文件 ls 请求。一期全量返回命中范围内的所有节点，\n不提供分页参数。后续可能扩展 `tag` / 时间窗等维度，新增字段\n直接平铺在本对象下，不破坏现有外形。\n
 */
export const scenarioListRequestSchema = z.object({
    "path_prefix": z.optional(z.string().describe("目录前缀。空字符串 `\"\"` 或不传表示根目录；示例：\n`工作/`。值由 JSON body 承载，无需 `encodeURIComponent`。\n"))
    }).describe("L2 场景文件 ls 请求。一期全量返回命中范围内的所有节点，\n不提供分页参数。后续可能扩展 `tag` / 时间窗等维度，新增字段\n直接平铺在本对象下，不破坏现有外形。\n") as unknown as z.ZodType<ScenarioListRequest>

/**
 * @description L2 场景文件目录项。`path` 末尾带 `/` 表示目录，否则为文件；\n调用方据此自行区分两类节点。目录项不返回 `size`。\n
 */
export const scenarioEntrySchema = z.object({
    "path": z.string().describe("完整路径。文件形如 `工作/交付物/2026Q1.md`；目录以 `/` 结尾，\n形如 `工作/交付物/`。\n"),
"summary": z.optional(z.string().describe("场景文件摘要（来自 META 区域或 scene_index）。目录项无此字段。")),
"created_at": z.iso.datetime().describe("创建时间。"),
"updated_at": z.iso.datetime().describe("最近一次更新时间。")
    }).describe("L2 场景文件目录项。`path` 末尾带 `/` 表示目录，否则为文件；\n调用方据此自行区分两类节点。目录项不返回 `size`。\n") as unknown as z.ZodType<ScenarioEntry>

export const scenarioListDataSchema = z.object({
    get "entries"(){
                return z.array(scenarioEntrySchema.describe("L2 场景文件目录项。`path` 末尾带 `/` 表示目录，否则为文件；\n调用方据此自行区分两类节点。目录项不返回 `size`。\n"))
              },
"total": z.int().describe("满足前缀过滤的目录项总数。")
    }) as unknown as z.ZodType<ScenarioListData>

/**
 * @description L2 场景文件完整视图（含正文）。
 */
export const scenarioFileSchema = z.object({
    "path": z.string().describe("完整路径。"),
"content": z.string().describe("Markdown 文件原文（含内核约定的 META 区域）。"),
"created_at": z.iso.datetime(),
"updated_at": z.iso.datetime()
    }).describe("L2 场景文件完整视图（含正文）。") as unknown as z.ZodType<ScenarioFile>

/**
 * @description L2 场景文件读取请求。`path` 指向目标文件完整路径；由 JSON body\n承载，无需 `encodeURIComponent`，可直接包含中文、深层目录与特殊字符。\n
 */
export const scenarioReadRequestSchema = z.object({
    "path": z.string().describe("目标文件完整路径，例如 `工作/交付物/2026Q1.md`。")
    }).describe("L2 场景文件读取请求。`path` 指向目标文件完整路径；由 JSON body\n承载，无需 `encodeURIComponent`，可直接包含中文、深层目录与特殊字符。\n") as unknown as z.ZodType<ScenarioReadRequest>

/**
 * @description L2 场景节点删除请求。`path` 既可指向文件也可指向目录；删除目录\n时按内核侧约定的递归策略处理（详见接口描述）。\n
 */
export const scenarioRmRequestSchema = z.object({
    "path": z.string().describe("待删除节点完整路径（文件或目录）。")
    }).describe("L2 场景节点删除请求。`path` 既可指向文件也可指向目录；删除目录\n时按内核侧约定的递归策略处理（详见接口描述）。\n") as unknown as z.ZodType<ScenarioRmRequest>

/**
 * @description L2 场景文件全量覆盖写入请求。`path` 指向**已存在的**目标文件，\n`content` 为本次写入的全量正文（内核会整体覆盖旧内容，不做\ndiff / merge）；`summary` **选填**，为该文件的一句话摘要，\n字段缺省则不更新摘要、显式传入则整体覆盖。本期不支持\"按\npath 不存在则创建\"的 upsert 语义；目标 `path` 不存在或不\n属于当前调用上下文时，统一返回业务错误码 `404`。\n
 */
export const scenarioWriteRequestSchema = z.object({
    "path": z.string().describe("目标文件完整路径，例如 `工作/交付物/2026Q1.md`。由 JSON body\n承载，无需 `encodeURIComponent`。该路径必须已存在，否则\n返回 `404`。\n"),
"content": z.string().describe("本次写入的全量正文，将整体覆盖目标文件旧内容。"),
"summary": z.optional(z.string().describe("该场景文件的一句话摘要，用于 `POST /scenario/ls` 等列表\n场景下的快速概览。**选填**：字段缺省表示本次不更新摘要；\n显式传入空串 `\"\"` 则代表清空摘要。\n"))
    }).describe("L2 场景文件全量覆盖写入请求。`path` 指向**已存在的**目标文件，\n`content` 为本次写入的全量正文（内核会整体覆盖旧内容，不做\ndiff / merge）；`summary` **选填**，为该文件的一句话摘要，\n字段缺省则不更新摘要、显式传入则整体覆盖。本期不支持\"按\npath 不存在则创建\"的 upsert 语义；目标 `path` 不存在或不\n属于当前调用上下文时，统一返回业务错误码 `404`。\n") as unknown as z.ZodType<ScenarioWriteRequest>

export const scenarioWriteDataSchema = z.object({
    "path": z.string().describe("写入生效的文件完整路径（回显入参 `path`，便于调用方链路对账）。"),
"updated_at": z.iso.datetime().describe("本次写入生效时间。")
    }) as unknown as z.ZodType<ScenarioWriteData>

/**
 * @description L3 核心记忆文件完整视图。
 */
export const coreFileSchema = z.object({
    "content": z.string().describe("Markdown 核心记忆原文。"),
"created_at": z.iso.datetime(),
"updated_at": z.iso.datetime()
    }).describe("L3 核心记忆文件完整视图。") as unknown as z.ZodType<CoreFile>

/**
 * @description L3 核心记忆读取请求。L3 路径由内核固定（Agent 维度单体），调用方\n无需也不应传入 `path`。一期 body 为空对象 `{}` 即可，预留二期\n扩展位（如版本号、字段投影等）。\n
 */
export const coreReadRequestSchema = z.object({
    
    }).describe("L3 核心记忆读取请求。L3 路径由内核固定（Agent 维度单体），调用方\n无需也不应传入 `path`。一期 body 为空对象 `{}` 即可，预留二期\n扩展位（如版本号、字段投影等）。\n") as unknown as z.ZodType<CoreReadRequest>

/**
 * @description L3 核心记忆全量覆盖写入请求。`content` 为本次写入的全量正文，\n内核会整体覆盖旧内容，不做 diff / merge。L3 文件路径在内核侧\n固定（Agent 维度单体），无需调用方传入。\n
 */
export const coreWriteRequestSchema = z.object({
    "content": z.string().describe("本次写入的全量正文，将整体覆盖核心记忆旧内容。")
    }).describe("L3 核心记忆全量覆盖写入请求。`content` 为本次写入的全量正文，\n内核会整体覆盖旧内容，不做 diff / merge。L3 文件路径在内核侧\n固定（Agent 维度单体），无需调用方传入。\n") as unknown as z.ZodType<CoreWriteRequest>

export const coreWriteDataSchema = z.object({
    "updated_at": z.iso.datetime().describe("本次写入生效时间。")
    }) as unknown as z.ZodType<CoreWriteData>

/**
 * @description L0 消息双路语义检索请求。所有字段均**平铺**在顶层；筛选字段\n与 `ConversationQueryRequest` 同形（`session_id` / `time_start` /\n`time_end`），用于召回前的预过滤窗。本接口为 Top-K 召回，\n不提供 `offset`。\n
 */
export const conversationSearchRequestSchema = z.object({
    "query": z.string().min(1).max(2048).describe("检索文本，长度上限 2 KB。"),
"limit": z.optional(z.int().min(1).max(100).default(5).describe("返回条数上限（Top-K）。")),
"session_id": z.optional(z.string().describe("按会话过滤（召回前预过滤）。")),
"time_start": z.optional(z.iso.datetime().describe("起始时间过滤（含端点）。")),
"time_end": z.optional(z.iso.datetime().describe("结束时间过滤（含端点）。"))
    }).describe("L0 消息双路语义检索请求。所有字段均**平铺**在顶层；筛选字段\n与 `ConversationQueryRequest` 同形（`session_id` / `time_start` /\n`time_end`），用于召回前的预过滤窗。本接口为 Top-K 召回，\n不提供 `offset`。\n") as unknown as z.ZodType<ConversationSearchRequest>

/**
 * @description L0 消息检索命中项。形状在 `ConversationItem` 基础上叠加只读 `score`\n字段（其余字段语义与 `ConversationItem` 一致，含只读 `id`）。\n
 */
export const conversationSearchHitSchema = z.lazy(() => conversationItemSchema).and(z.object({
    "score": z.number().describe("相关度分数，越大越相关；数值由内核侧双路融合后给出，\n跨请求不保证可比。\n")
    })).describe("L0 消息检索命中项。形状在 `ConversationItem` 基础上叠加只读 `score`\n字段（其余字段语义与 `ConversationItem` 一致，含只读 `id`）。\n") as unknown as z.ZodType<ConversationSearchHit>

export const conversationSearchDataSchema = z.object({
    get "messages"(){
                return z.array(conversationSearchHitSchema.describe("L0 消息检索命中项。形状在 `ConversationItem` 基础上叠加只读 `score`\n字段（其余字段语义与 `ConversationItem` 一致，含只读 `id`）。\n")).describe("L0 消息检索命中列表，按 `score` 倒序排列；列表长度\n不超过请求 `limit`。字段命名与 `ConversationQueryData.messages`\n对齐，便于调用方复用 query 的消费链路。\n")
              }
    }) as unknown as z.ZodType<ConversationSearchData>

/**
 * @description L1 笔记双路语义检索请求。所有字段均**平铺**在顶层；筛选字段\n与 `AtomicQueryRequest` 同形（`type` / `time_start` /\n`time_end`），用于召回前的预过滤窗。本接口为 Top-K 召回，\n不提供 `offset`。\n
 */
export const atomicSearchRequestSchema = z.object({
    "query": z.string().min(1).max(2048).describe("检索文本，长度上限 2 KB。"),
"limit": z.optional(z.int().min(1).max(100).default(5).describe("返回条数上限（Top-K）。")),
"type": z.optional(z.string().describe("按 L1 记忆类型过滤。当前取值：`episodic` / `persona` /\n`instruction`；后续可能扩展。\n")),
"time_start": z.optional(z.iso.datetime().describe("按 `updated_at` 起始时间过滤（含端点）。")),
"time_end": z.optional(z.iso.datetime().describe("按 `updated_at` 结束时间过滤（含端点）。"))
    }).describe("L1 笔记双路语义检索请求。所有字段均**平铺**在顶层；筛选字段\n与 `AtomicQueryRequest` 同形（`type` / `time_start` /\n`time_end`），用于召回前的预过滤窗。本接口为 Top-K 召回，\n不提供 `offset`。\n") as unknown as z.ZodType<AtomicSearchRequest>

/**
 * @description L1 笔记检索命中项。形状在 `AtomicDetail` 基础上叠加只读 `score`\n字段（其余字段语义与 `AtomicDetail` 一致）。\n
 */
export const atomicSearchHitSchema = z.lazy(() => atomicDetailSchema).and(z.object({
    "score": z.number().describe("相关度分数，越大越相关；数值由内核侧双路融合后给出，\n跨请求不保证可比。\n")
    })).describe("L1 笔记检索命中项。形状在 `AtomicDetail` 基础上叠加只读 `score`\n字段（其余字段语义与 `AtomicDetail` 一致）。\n") as unknown as z.ZodType<AtomicSearchHit>

export const atomicSearchDataSchema = z.object({
    get "items"(){
                return z.array(atomicSearchHitSchema.describe("L1 笔记检索命中项。形状在 `AtomicDetail` 基础上叠加只读 `score`\n字段（其余字段语义与 `AtomicDetail` 一致）。\n")).describe("L1 笔记检索命中列表，按 `score` 倒序排列；列表长度\n不超过请求 `limit`。字段命名与 `AtomicQueryData.items` 对齐，\n便于调用方复用 query 的消费链路。\n")
              }
    }) as unknown as z.ZodType<AtomicSearchData>

/**
 * @description 受理成功
 */
export const addConversation200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return conversationAddDataSchema.optional()
              }
    })) as unknown as z.ZodType<AddConversation200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const addConversationErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<AddConversationError>

export const addConversationMutationRequestSchema = z.lazy(() => conversationAddRequestSchema) as unknown as z.ZodType<AddConversationMutationRequest>

export const addConversationMutationResponseSchema = z.lazy(() => addConversation200Schema) as unknown as z.ZodType<AddConversationMutationResponse>

/**
 * @description 查询成功
 */
export const queryConversation200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return conversationQueryDataSchema.optional()
              }
    })) as unknown as z.ZodType<QueryConversation200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const queryConversationErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<QueryConversationError>

export const queryConversationMutationRequestSchema = z.lazy(() => conversationQueryRequestSchema).describe("L0 消息查询请求。所有字段均**平铺**在顶层；筛选字段全部可选，\n不传等价于\"不加筛选、仅按分页返回\"。\n") as unknown as z.ZodType<QueryConversationMutationRequest>

export const queryConversationMutationResponseSchema = z.lazy(() => queryConversation200Schema) as unknown as z.ZodType<QueryConversationMutationResponse>

/**
 * @description 检索成功
 */
export const searchConversation200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return conversationSearchDataSchema.optional()
              }
    })) as unknown as z.ZodType<SearchConversation200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const searchConversationErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<SearchConversationError>

export const searchConversationMutationRequestSchema = z.lazy(() => conversationSearchRequestSchema).describe("L0 消息双路语义检索请求。所有字段均**平铺**在顶层；筛选字段\n与 `ConversationQueryRequest` 同形（`session_id` / `time_start` /\n`time_end`），用于召回前的预过滤窗。本接口为 Top-K 召回，\n不提供 `offset`。\n") as unknown as z.ZodType<SearchConversationMutationRequest>

export const searchConversationMutationResponseSchema = z.lazy(() => searchConversation200Schema) as unknown as z.ZodType<SearchConversationMutationResponse>

/**
 * @description 删除成功
 */
export const deleteConversation200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return conversationDeleteDataSchema.optional()
              }
    })) as unknown as z.ZodType<DeleteConversation200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const deleteConversationErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<DeleteConversationError>

export const deleteConversationMutationRequestSchema = z.lazy(() => conversationDeleteRequestSchema).describe("L0 消息批量删除请求。两种删除模式互斥，二选其一：\n\n  - **按 message id 批量删**：传 `message_ids`（非空数组），按\n    消息主键精确删除一组消息；不与 `session_id` 同时使用。\n  - **按 session 批量删**：传 `session_id`，按会话一次性删除\n    该会话下的全部消息；不与 `message_ids` 同时使用。\n\n所有字段全部缺省、或 `message_ids` 与 `session_id` 同时出现，\n均视为非法请求，返回业务错误码 `400`。本接口不带分页参数。\n") as unknown as z.ZodType<DeleteConversationMutationRequest>

export const deleteConversationMutationResponseSchema = z.lazy(() => deleteConversation200Schema) as unknown as z.ZodType<DeleteConversationMutationResponse>

/**
 * @description 更新成功
 */
export const updateAtomic200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return atomicUpdateDataSchema.describe("L1 笔记按 id 更新结果。回带笔记主键与本次更新生效时间，\n便于调用方对账。\n").optional()
              }
    })) as unknown as z.ZodType<UpdateAtomic200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const updateAtomicErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<UpdateAtomicError>

export const updateAtomicMutationRequestSchema = z.lazy(() => atomicUpdateRequestSchema).describe("L1 记忆笔记按 id 更新请求。`id` 定位目标笔记；`content` 为本次\n更新后的笔记正文全量值（整体覆盖旧值，不做 diff / merge）；\n`background` **选填**——传入则整体覆盖背景字段，不传（字段\n缺省）则保持原值不变。本接口不支持\"按 id 不存在则创建\"的\nupsert 语义；若 `id` 不存在或不属于当前调用上下文，统一返回\n业务错误码 `404`。\n") as unknown as z.ZodType<UpdateAtomicMutationRequest>

export const updateAtomicMutationResponseSchema = z.lazy(() => updateAtomic200Schema) as unknown as z.ZodType<UpdateAtomicMutationResponse>

/**
 * @description 查询成功
 */
export const queryAtomic200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return atomicQueryDataSchema.optional()
              }
    })) as unknown as z.ZodType<QueryAtomic200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const queryAtomicErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<QueryAtomicError>

export const queryAtomicMutationRequestSchema = z.lazy(() => atomicQueryRequestSchema) as unknown as z.ZodType<QueryAtomicMutationRequest>

export const queryAtomicMutationResponseSchema = z.lazy(() => queryAtomic200Schema) as unknown as z.ZodType<QueryAtomicMutationResponse>

/**
 * @description 检索成功
 */
export const searchAtomic200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return atomicSearchDataSchema.optional()
              }
    })) as unknown as z.ZodType<SearchAtomic200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const searchAtomicErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<SearchAtomicError>

export const searchAtomicMutationRequestSchema = z.lazy(() => atomicSearchRequestSchema).describe("L1 笔记双路语义检索请求。所有字段均**平铺**在顶层；筛选字段\n与 `AtomicQueryRequest` 同形（`type` / `time_start` /\n`time_end`），用于召回前的预过滤窗。本接口为 Top-K 召回，\n不提供 `offset`。\n") as unknown as z.ZodType<SearchAtomicMutationRequest>

export const searchAtomicMutationResponseSchema = z.lazy(() => searchAtomic200Schema) as unknown as z.ZodType<SearchAtomicMutationResponse>

/**
 * @description 删除成功
 */
export const deleteAtomic200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return atomicDeleteDataSchema.optional()
              }
    })) as unknown as z.ZodType<DeleteAtomic200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const deleteAtomicErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<DeleteAtomicError>

export const deleteAtomicMutationRequestSchema = z.lazy(() => atomicDeleteRequestSchema).describe("L1 笔记按 id 批量删除请求。本期仅支持按主键精确删除，不接受\n按 `type` / 时间区间等条件批删；`ids` 缺省或为空数组视为非法\n请求，返回业务错误码 `400`。本接口不带分页参数。\n") as unknown as z.ZodType<DeleteAtomicMutationRequest>

export const deleteAtomicMutationResponseSchema = z.lazy(() => deleteAtomic200Schema) as unknown as z.ZodType<DeleteAtomicMutationResponse>

/**
 * @description 列举成功
 */
export const lsScenario200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return scenarioListDataSchema.optional()
              }
    })) as unknown as z.ZodType<LsScenario200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const lsScenarioErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<LsScenarioError>

export const lsScenarioMutationRequestSchema = z.lazy(() => scenarioListRequestSchema).describe("L2 场景文件 ls 请求。一期全量返回命中范围内的所有节点，\n不提供分页参数。后续可能扩展 `tag` / 时间窗等维度，新增字段\n直接平铺在本对象下，不破坏现有外形。\n") as unknown as z.ZodType<LsScenarioMutationRequest>

export const lsScenarioMutationResponseSchema = z.lazy(() => lsScenario200Schema) as unknown as z.ZodType<LsScenarioMutationResponse>

/**
 * @description 读取成功
 */
export const readScenario200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return scenarioFileSchema.describe("L2 场景文件完整视图（含正文）。").optional()
              }
    })) as unknown as z.ZodType<ReadScenario200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const readScenarioErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<ReadScenarioError>

export const readScenarioMutationRequestSchema = z.lazy(() => scenarioReadRequestSchema).describe("L2 场景文件读取请求。`path` 指向目标文件完整路径；由 JSON body\n承载，无需 `encodeURIComponent`，可直接包含中文、深层目录与特殊字符。\n") as unknown as z.ZodType<ReadScenarioMutationRequest>

export const readScenarioMutationResponseSchema = z.lazy(() => readScenario200Schema) as unknown as z.ZodType<ReadScenarioMutationResponse>

/**
 * @description 写入成功
 */
export const writeScenario200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return scenarioWriteDataSchema.optional()
              }
    })) as unknown as z.ZodType<WriteScenario200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const writeScenarioErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<WriteScenarioError>

export const writeScenarioMutationRequestSchema = z.lazy(() => scenarioWriteRequestSchema).describe("L2 场景文件全量覆盖写入请求。`path` 指向**已存在的**目标文件，\n`content` 为本次写入的全量正文（内核会整体覆盖旧内容，不做\ndiff / merge）；`summary` **选填**，为该文件的一句话摘要，\n字段缺省则不更新摘要、显式传入则整体覆盖。本期不支持\"按\npath 不存在则创建\"的 upsert 语义；目标 `path` 不存在或不\n属于当前调用上下文时，统一返回业务错误码 `404`。\n") as unknown as z.ZodType<WriteScenarioMutationRequest>

export const writeScenarioMutationResponseSchema = z.lazy(() => writeScenario200Schema) as unknown as z.ZodType<WriteScenarioMutationResponse>

/**
 * @description 删除成功
 */
export const rmScenario200Schema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<RmScenario200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const rmScenarioErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<RmScenarioError>

export const rmScenarioMutationRequestSchema = z.lazy(() => scenarioRmRequestSchema).describe("L2 场景节点删除请求。`path` 既可指向文件也可指向目录；删除目录\n时按内核侧约定的递归策略处理（详见接口描述）。\n") as unknown as z.ZodType<RmScenarioMutationRequest>

export const rmScenarioMutationResponseSchema = z.lazy(() => rmScenario200Schema) as unknown as z.ZodType<RmScenarioMutationResponse>

/**
 * @description 读取成功
 */
export const readCore200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return coreFileSchema.describe("L3 核心记忆文件完整视图。").optional()
              }
    })) as unknown as z.ZodType<ReadCore200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const readCoreErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<ReadCoreError>

export const readCoreMutationRequestSchema = z.lazy(() => coreReadRequestSchema).describe("L3 核心记忆读取请求。L3 路径由内核固定（Agent 维度单体），调用方\n无需也不应传入 `path`。一期 body 为空对象 `{}` 即可，预留二期\n扩展位（如版本号、字段投影等）。\n") as unknown as z.ZodType<ReadCoreMutationRequest>

export const readCoreMutationResponseSchema = z.lazy(() => readCore200Schema) as unknown as z.ZodType<ReadCoreMutationResponse>

/**
 * @description 写入成功
 */
export const writeCore200Schema = z.lazy(() => apiResponseEnvelopeSchema).and(z.object({
    get "data"(){
                return coreWriteDataSchema.optional()
              }
    })) as unknown as z.ZodType<WriteCore200>

/**
 * @description 业务错误（HTTP 200/4xx/5xx 均可能返回）
 */
export const writeCoreErrorSchema = z.lazy(() => apiResponseEnvelopeSchema) as unknown as z.ZodType<WriteCoreError>

export const writeCoreMutationRequestSchema = z.lazy(() => coreWriteRequestSchema).describe("L3 核心记忆全量覆盖写入请求。`content` 为本次写入的全量正文，\n内核会整体覆盖旧内容，不做 diff / merge。L3 文件路径在内核侧\n固定（Agent 维度单体），无需调用方传入。\n") as unknown as z.ZodType<WriteCoreMutationRequest>

export const writeCoreMutationResponseSchema = z.lazy(() => writeCore200Schema) as unknown as z.ZodType<WriteCoreMutationResponse>