@shwfed/config 2.11.5 → 2.12.0

package/dist/runtime/components/table/utils/ai-tools.js

@@ -0,0 +1,458 @@
+import { JSONSchema, ParseResult, Schema } from "effect";
+import { coerceFromString } from "../../../share/coerce-from-string.js";
+import { Expression, HttpRequestResult } from "../../../share/expression.js";
+import {
+  defaultTableConfig,
+  registerDataSourceRequestVars,
+  registerDataSourceResponseVars
+} from "../schema.js";
+import { registerRowVariablesIfAbsent } from "./shared.js";
+import { activeColumns } from "./resolve.js";
+const HARNESS_KEYS = ["id", "groupId", "compatibilityDate"];
+function publicColumnSchema(entry, configure) {
+  return entry.schema(configure).pipe(Schema.omit(...HARNESS_KEYS));
+}
+function decode(schema, input) {
+  const result = Schema.decodeUnknownEither(schema)(coerceFromString(input, schema));
+  if (result._tag === "Right") return { ok: true, value: result.right };
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(result.left);
+  const report = issues.map((i) => `- ${i.path.map(String).join(".") || "(root)"}: ${i.message}`).join("\n");
+  return { ok: false, report };
+}
+function decodeField(field, schema, value) {
+  const result = Schema.decodeUnknownEither(schema)(value);
+  if (result._tag === "Right") return null;
+  const message = ParseResult.ArrayFormatter.formatErrorSync(result.left)[0]?.message ?? "invalid";
+  return `${field}: ${message}`;
+}
+function buildDataSourceExpressionSchemas(configure) {
+  return {
+    request: Expression({
+      configure: (env) => {
+        configure(env);
+        registerDataSourceRequestVars(env);
+      },
+      resultType: HttpRequestResult
+    }),
+    data: Expression({
+      configure: (env) => {
+        configure(env);
+        registerDataSourceResponseVars(env);
+      },
+      // Mirrors `tableDataSource`'s `CelRows` resultType: list / dyn /
+      // optional<T> all pass — a data expression that yields a parsed JSON
+      // array (the common case), a `dyn`, or `optional<list<…>>` is fine.
+      resultType: (t) => t.startsWith("list") || t === "dyn" || t.startsWith("optional")
+    }),
+    total: Expression({
+      configure: (env) => {
+        configure(env);
+        registerDataSourceResponseVars(env);
+      },
+      // Mirrors `tableDataSource`'s `CelTotal` resultType: a server-total
+      // expression that resolves to a number, `dyn`, or `optional<number>`
+      // is acceptable (the runtime normalizes None → 0 on the wire).
+      resultType: (t) => t === "number" || t === "dyn" || t.startsWith("optional")
+    })
+  };
+}
+function buildRowKeyExpressionSchema(configure) {
+  return Expression({
+    configure: (env) => {
+      configure(env);
+      registerRowVariablesIfAbsent(env);
+    },
+    // Mirrors `TableConfig`'s `CelRowKey` resultType: row-key expressions
+    // resolve to a string, number, or `dyn` (the runtime hashes anything
+    // non-string to a stable string for TanStack's row.id).
+    resultType: (t) => t === "string" || t === "number" || t === "dyn"
+  });
+}
+function safeJsonSchema(schema) {
+  try {
+    return JSONSchema.make(schema);
+  } catch {
+    return "(schema unavailable)";
+  }
+}
+export function createTableAiTools(deps) {
+  const dataSourceSchemas = buildDataSourceExpressionSchemas(deps.configure);
+  const rowKeySchema = buildRowKeyExpressionSchema(deps.configure);
+  return [
+    // ---- 信息获取 ----
+    {
+      name: "list_available_column_types",
+      description: "List the column types you can currently insert into a table. Returns each type's name and, when set, a one-line description of when to use it. Use this first to discover what columns exist; for a column's full field contract and defaults, follow up with `describe_specific_column_type`. Deprecated types are hidden.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      execute: () => activeColumns().map((c) => {
+        const entry = { type: c.type, name: c.metadata.name };
+        if (c.metadata.description !== void 0) entry.description = c.metadata.description;
+        return entry;
+      })
+    },
+    {
+      name: "describe_specific_column_type",
+      description: "Return the JSON Schema (without `id`/`groupId` \u2014 those are managed by the harness) and the default values for one column type. Call this before `insert_column` to learn the field contract. Deprecated types are not accepted.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          type: { type: "string", description: "A `type` value from `list_available_column_types`." }
+        },
+        required: ["type"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const { type } = input ?? {};
+        if (typeof type !== "string" || type.length === 0) {
+          return "describe failed: `type` must be a non-empty string.";
+        }
+        const entry = activeColumns().find((c) => c.type === type);
+        if (!entry) {
+          return `describe failed: column type "${type}" is not available. Call list_available_column_types to see what is.`;
+        }
+        const publicSchema = publicColumnSchema(entry, deps.configure);
+        let jsonSchema;
+        try {
+          jsonSchema = JSONSchema.make(publicSchema);
+        } catch {
+          jsonSchema = "(schema unavailable)";
+        }
+        return {
+          schema: jsonSchema,
+          defaults: entry.defaults?.() ?? null
+        };
+      }
+    },
+    {
+      name: "describe_general_settings",
+      description: "Return the schema and current values for the table's general settings: `displayName` (internal label), `dataSource` (HTTP request / data extraction / total \u2014 each with its own CEL scope and available variables baked into the JSON Schema description), `rowKey` (per-row CEL expression evaluated against `row` / `index`), and the `pagination` toggle's current on/off state. Call this first when configuring a fresh table from API documentation; the CEL expressions reference the same scopes the inline UI validates against, so what you learn here is what the setters accept.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      execute: () => {
+        const working = deps.read();
+        const dataSource = working.dataSource;
+        return {
+          values: {
+            displayName: typeof working.displayName === "string" ? working.displayName : null,
+            dataSource: dataSource ? {
+              request: dataSource.request ?? null,
+              data: dataSource.data ?? null,
+              total: dataSource.total ?? null
+            } : null,
+            rowKey: typeof working.rowKey === "string" ? working.rowKey : null,
+            // The toggle's current state — does NOT expose pageSize/pageSizes,
+            // those are user-facing knobs the AI never needs to set.
+            paginationEnabled: working.pagination !== void 0
+          },
+          fields: [
+            {
+              name: "displayName",
+              title: "\u5185\u90E8\u540D\u79F0",
+              description: "\u4EC5\u5728\u914D\u7F6E\u754C\u9762\u53EF\u89C1\u7684\u8868\u683C\u540D\u79F0\uFF0C\u7528\u4E8E\u5728\u4E8B\u4EF6\u76EE\u6807\u7B49\u4F4D\u7F6E\u6807\u8BC6\u8BE5\u8868\u683C\uFF1B\u8FD0\u884C\u65F6\u4E0D\u5C55\u793A\u3002",
+              kind: "string"
+            },
+            {
+              name: "dataSource",
+              title: "\u6570\u636E\u6E90",
+              kind: "group",
+              subfields: [
+                {
+                  name: "request",
+                  title: "\u8BF7\u6C42",
+                  description: "\u53EF\u9009\u7684 HTTP \u8BF7\u6C42\u8868\u8FBE\u5F0F\uFF1B\u672A\u914D\u7F6E\u65F6\u6570\u636E\u4ECE `data` \u8868\u8FBE\u5F0F\u4E2D\u8BFB\u53D6\uFF08\u901A\u5E38\u5F15\u7528\u4E0A\u4E0B\u6587\u53D8\u91CF\uFF09\u3002",
+                  kind: "cel",
+                  resultType: "HttpRequest | optional<HttpRequest> | dyn | optional<dyn>",
+                  jsonSchema: safeJsonSchema(dataSourceSchemas.request)
+                },
+                {
+                  name: "data",
+                  title: "\u6570\u636E",
+                  description: "\u8FD4\u56DE\u884C\u6570\u636E\u5217\u8868\uFF08`list<dyn>`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u5728\u914D\u7F6E\u4E86 `request` \u65F6\u53EF\u901A\u8FC7 `json` \u5F15\u7528\u54CD\u5E94\u4F53\u3002",
+                  kind: "cel",
+                  resultType: "list<\u2026> | dyn | optional<\u2026>",
+                  jsonSchema: safeJsonSchema(dataSourceSchemas.data)
+                },
+                {
+                  name: "total",
+                  title: "\u603B\u6570",
+                  description: "\u8FD4\u56DE\u603B\u884C\u6570\uFF08`number`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u914D\u7F6E\u540E\u542F\u7528\u670D\u52A1\u7AEF\u5206\u9875\uFF0C\u7559\u7A7A\u5219\u8D70\u524D\u7AEF\u5206\u9875\u3002",
+                  kind: "cel",
+                  resultType: "number | dyn | optional<\u2026>",
+                  jsonSchema: safeJsonSchema(dataSourceSchemas.total)
+                }
+              ]
+            },
+            {
+              name: "rowKey",
+              title: "\u884C\u552F\u4E00\u6807\u8BC6",
+              description: "\u4E3A\u6BCF\u4E00\u884C\u8BA1\u7B97\u7A33\u5B9A\u552F\u4E00 ID \u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `row` / `index`\uFF0C\u7ED3\u679C\u987B\u4E3A\u5B57\u7B26\u4E32\u6216\u6570\u5B57\uFF08\u4F8B\u5982 `row.id`\uFF09\u3002\u914D\u7F6E\u540E\uFF0C\u8DE8\u5237\u65B0\u7684\u52FE\u9009\u3001\u5C55\u5F00\u7B49\u884C\u7EA7\u72B6\u6001\u6309\u8BE5 ID \u5339\u914D\uFF1B\u7559\u7A7A\u65F6\u884C\u8EAB\u4EFD\u6309\u5BF9\u8C61\u5F15\u7528\u515C\u5E95\uFF0C\u8FDC\u7AEF\u6570\u636E\u5237\u65B0\u4F1A\u4E22\u3002",
+              kind: "cel",
+              resultType: "string | number | dyn",
+              jsonSchema: safeJsonSchema(rowKeySchema)
+            },
+            {
+              name: "pagination",
+              title: "\u5206\u9875",
+              description: "\u5206\u9875\u7EC4\u4EF6\u5F00\u5173\uFF1B\u5F00\u542F\u540E\u7528\u6237\u770B\u5230\u5206\u9875\u5668\uFF0C\u5173\u95ED\u5219\u4E00\u6B21\u6027\u6E32\u67D3\u6240\u6709\u6570\u636E\u3002`pageSize` \u7B49\u5177\u4F53\u53C2\u6570\u8BF7\u5728\u53F3\u4FA7\u9762\u677F\u914D\u7F6E\u3002",
+              kind: "toggle",
+              enabled: working.pagination !== void 0
+            }
+          ]
+        };
+      }
+    },
+    // ---- 配置 ----
+    {
+      name: "insert_column",
+      description: "Insert one new column into the table. Provide `type` (from `list_available_column_types`) plus the column's fields as described by `describe_specific_column_type`. Do NOT include `id` or `groupId` \u2014 the harness assigns `id` automatically and grouping is a separate operation. On validation failure the tool returns the issues; fix them and call again.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          type: { type: "string", description: "The column type to insert." }
+        },
+        required: ["type"],
+        additionalProperties: true
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        const { type, ...rest } = raw;
+        if (typeof type !== "string" || type.length === 0) {
+          return "insert failed: `type` must be a non-empty string.";
+        }
+        for (const k of HARNESS_KEYS) {
+          if (k in rest) {
+            return `insert failed: do not pass \`${k}\` \u2014 the harness assigns it.`;
+          }
+        }
+        const entry = activeColumns().find((c) => c.type === type);
+        if (!entry) {
+          return `insert failed: column type "${type}" is not available. Call list_available_column_types to see what is.`;
+        }
+        const publicSchema = publicColumnSchema(entry, deps.configure);
+        const verdict = decode(publicSchema, raw);
+        if (!verdict.ok) {
+          return `insert failed for type "${type}". Fix these and call insert_column again:
+${verdict.report}`;
+        }
+        const working = deps.read();
+        const columns = Array.isArray(working.columns) ? working.columns : [];
+        const newColumn = {
+          id: deps.genUuid(),
+          compatibilityDate: entry.compatibilityDate,
+          ...verdict.value
+        };
+        working.columns = [...columns, newColumn];
+        deps.write(working);
+        return { id: newColumn.id, type };
+      }
+    },
+    {
+      name: "delete_columns",
+      description: "Delete one or more columns by id. Call `list_columns` first to obtain ids. Columns are matched by id only (type / title are not unique). On any unknown id the call is rejected without writing; fix and call again. This does not touch group definitions; grouping remains a separate operation.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          ids: {
+            type: "array",
+            items: { type: "string", minLength: 1 },
+            minItems: 1,
+            description: "Column ids to delete. Get them from `list_columns` first."
+          }
+        },
+        required: ["ids"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        const ids = raw.ids;
+        if (!Array.isArray(ids) || ids.length === 0) {
+          return "delete failed: `ids` must be a non-empty array of column ids.";
+        }
+        for (const id of ids) {
+          if (typeof id !== "string" || id.length === 0) {
+            return "delete failed: every `ids` entry must be a non-empty string.";
+          }
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const id of ids) {
+          if (seen.has(id)) {
+            return `delete failed: duplicate id "${id}" in input \u2014 dedupe and call again.`;
+          }
+          seen.add(id);
+        }
+        const working = deps.read();
+        const columns = Array.isArray(working.columns) ? working.columns : [];
+        const existing = new Set(columns.map((c) => c.id));
+        for (const id of ids) {
+          if (!existing.has(id)) {
+            return `delete failed: column id "${id}" is not present. Call list_columns to see current ids.`;
+          }
+        }
+        const deleted = new Set(ids);
+        working.columns = columns.filter((c) => !deleted.has(c.id));
+        deps.write(working);
+        return { deleted: ids, count: ids.length };
+      }
+    },
+    {
+      name: "list_columns",
+      description: "Return the currently-configured columns, including their `id` and `groupId`. Use this to discover existing ids (e.g. before grouping them in a later step).",
+      inputJsonSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      execute: () => {
+        const working = deps.read();
+        return Array.isArray(working.columns) ? working.columns : [];
+      }
+    },
+    {
+      name: "set_display_name",
+      description: `Set the table's internal label (used in event-target pickers and the config tree; not shown to end users). Pass an empty string to clear it. The same setter is used for both set and clear \u2014 empty is a valid intentional state, not a "missing" one.`,
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          value: { type: "string", description: 'The new display name; pass `""` to clear.' }
+        },
+        required: ["value"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        if (typeof raw.value !== "string") {
+          return "set_display_name failed: `value` must be a string.";
+        }
+        const working = deps.read();
+        if (raw.value.length === 0) {
+          delete working.displayName;
+        } else {
+          working.displayName = raw.value;
+        }
+        deps.write(working);
+        return { displayName: working.displayName ?? null };
+      }
+    },
+    {
+      name: "set_data_source",
+      description: "Update one or more of the table's three `dataSource` CEL expressions: `request` (HTTP request), `data` (row extraction from response), `total` (server-side total count, leave empty for client-side pagination). Provide only the fields you want to change \u2014 omitted fields are inherited from the existing `dataSource`. At least one non-empty expression must be provided. `data` is required across the merged result (it stays from the existing source if you don't pass it). On CEL error the tool returns per-field messages; fix and call again.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          request: { type: "string", description: "HTTP request CEL expression (optional)." },
+          data: { type: "string", description: "Row extraction CEL expression (optional; preserved from existing if omitted)." },
+          total: { type: "string", description: "Total count CEL expression (optional; leave empty for client pagination)." }
+        },
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        const updates = {};
+        const provided = [];
+        for (const k of ["request", "data", "total"]) {
+          const v = raw[k];
+          if (v === void 0) continue;
+          if (typeof v !== "string") {
+            return `set_data_source failed: \`${k}\` must be a string when provided.`;
+          }
+          if (v.length === 0) {
+            return `set_data_source failed: \`${k}\` cannot be empty (omit the field to leave it unchanged).`;
+          }
+          updates[k] = v;
+          provided.push(k);
+        }
+        if (provided.length === 0) {
+          return "set_data_source failed: provide at least one of `request` / `data` / `total`.";
+        }
+        const fieldErrors = provided.map((k) => {
+          const schema = dataSourceSchemas[k];
+          return decodeField(k, schema, updates[k]);
+        }).filter((x) => x !== null);
+        if (fieldErrors.length > 0) {
+          return `set_data_source failed. Fix these and call set_data_source again:
+${fieldErrors.map((e) => `- ${e}`).join("\n")}`;
+        }
+        const working = deps.read();
+        const existing = working.dataSource ?? {};
+        const merged = { ...existing, ...updates };
+        if (typeof merged.data !== "string" || merged.data.length === 0) {
+          return "set_data_source failed: `data` is required (no existing dataSource.data to inherit).";
+        }
+        working.dataSource = merged;
+        deps.write(working);
+        return { dataSource: merged };
+      }
+    },
+    {
+      name: "set_row_key",
+      description: "Set the CEL expression that derives each row's stable id from the row payload (e.g. `row.id`, `row.?code`). Required scope: `row` (the current row object) and `index` (its zero-based position). The result must be a string, number, or `dyn` \u2014 anything else is rejected. Pass an empty string to clear the override (rows will fall back to the runtime's object-identity key, which fails to match after a remote refresh). On CEL error the tool returns the issue; fix and call again.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          value: { type: "string", description: 'Row-key CEL expression; pass `""` to clear.' }
+        },
+        required: ["value"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        if (typeof raw.value !== "string") {
+          return "set_row_key failed: `value` must be a string.";
+        }
+        if (raw.value.length > 0) {
+          const err = decodeField("value", rowKeySchema, raw.value);
+          if (err !== null) {
+            return `set_row_key failed. Fix this and call set_row_key again:
+- ${err}`;
+          }
+        }
+        const working = deps.read();
+        if (raw.value.length === 0) {
+          delete working.rowKey;
+        } else {
+          working.rowKey = raw.value;
+        }
+        deps.write(working);
+        return { rowKey: working.rowKey ?? null };
+      }
+    },
+    {
+      name: "set_pagination",
+      description: "Toggle the table's pagination component on or off. This is the one pagination knob AI controls \u2014 `pageSize` and `pageSizes` are user-facing knobs in the right-side panel and the AI does not set them. `enabled: true` seeds a sensible default (`pageSize: 100`, common `pageSizes` list) when there is no existing pagination, and is a no-op when one is already set (preserves whatever the user tuned). `enabled: false` removes the pagination field entirely. This tool does NOT touch `dataSource.total` \u2014 leaving the total expression in place is a legal state; the user can clear it from the panel if they want to drop server-side pagination alongside this toggle.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          enabled: { type: "boolean", description: "Whether the pagination component should be visible." }
+        },
+        required: ["enabled"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        if (typeof raw.enabled !== "boolean") {
+          return "set_pagination failed: `enabled` must be a boolean.";
+        }
+        const working = deps.read();
+        const currentlySet = working.pagination !== void 0;
+        if (raw.enabled) {
+          if (!currentlySet) {
+            working.pagination = { ...defaultTableConfig().pagination };
+          }
+        } else {
+          if (currentlySet) {
+            delete working.pagination;
+          }
+        }
+        deps.write(working);
+        return { enabled: working.pagination !== void 0, pagination: working.pagination ?? null };
+      }
+    }
+  ];
+}

package/dist/runtime/components/table/utils/resolve.d.ts

@@ -9,6 +9,12 @@ type SchemaFactory = (configure: (env: Environment) => void) => AnySchema;
 export type ColumnMetadata = Readonly<{
     name: string;
     icon: string;
+    /**
+     * 一句话说明该列的适用场景；AI 在 `list_available_column_types` 工具里看到。
+     * **可选** —— 用户后续按列单独补；缺失时工具返回里省略该字段，工具与 schema
+     * 都不报错（人类 picker / 旧调用点不受影响）。AI 工具以外不应读取该字段。
+     */
+    description?: string;
     /**
      * True when this column publishes its resolved option to the per-row
      * `selections` registry (its runtime keyed by `column.id`). Set it together
@@ -103,4 +109,21 @@ export declare function findColumn(type: string, compatibilityDate: string): Col
  */
 export declare function findMigrationTarget(type: string, compatibilityDate: string): ColumnEntry | undefined;
 export declare function latestColumnByType(): ReadonlyArray<ColumnEntry>;
+/**
+ * AI 工具可见的列集合：按 `type` 取最新版本 + 排除 `deprecated`。
+ *
+ * 两层过滤的原因：
+ *   (a) `latestColumnByType()` 解决同 `type` 多版本时只留最新版——避免 AI 拿到
+ *       已被新版本替代的旧 `compatibilityDate`（我们对 AI 隐藏 compDate，所以
+ *       不能让它先查到旧版再被 supersededBy 推回去，多绕一步）；
+ *   (b) `!deprecated` 同时屏蔽两类情况：
+ *       - 同 type 不同日期——已由 (a) 消除（因为旧日期 = deprecated）；
+ *       - 跨类型迁移的源条目——`deriveEntryExtras` 给所有被 `migrateFrom` 指
+ *         名的源都打了 `deprecated: true`，AI 永远不会看到它们，避免它读取到
+ *         一个 schema 还在但应被迁移的旧 type 后误以为是合法 API。
+ *
+ * 人类 picker 仍走 `COLUMNS`（含废弃）—— picker 的存在意义就是让用户能选到旧
+ * 列再触发迁移。
+ */
+export declare function activeColumns(): ReadonlyArray<ColumnEntry>;
 export {};

package/dist/runtime/components/table/utils/resolve.js

@@ -116,3 +116,6 @@ export function latestColumnByType() {
   }
   return [...byType.values()];
 }
+export function activeColumns() {
+  return latestColumnByType().filter((e) => !e.deprecated);
+}

package/dist/runtime/components/table/utils/shared.d.ts

@@ -8,49 +8,73 @@ export declare function columnIdentityFields(): {
     groupId: Schema.optional<typeof Schema.UUID>;
 };
 export declare function columnFields(configure: (env: Environment) => void): {
-    title: Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>;
+    title: Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>;
     accessor: Schema.optional<Schema.Schema<string, string, never>>;
     enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     sortKey: Schema.optional<Schema.refine<string, typeof Schema.String>>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    tooltip: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     hidden: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     id: Schema.refine<string, typeof Schema.String>;
     groupId: Schema.optional<typeof Schema.UUID>;
 };
 export declare function editableColumnFields(): {
-    title: Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>;
+    title: Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>;
     binding: Schema.refine<string, typeof Schema.String>;
     enableSorting: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     sortKey: Schema.optional<Schema.refine<string, typeof Schema.String>>;
     size: Schema.optional<Schema.refine<number, Schema.filter<typeof Schema.Number>>>;
     grow: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
-    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
-        locale: Schema.Literal<["zh"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>], [Schema.Struct<{
-        locale: Schema.Literal<["ja", "en", "ko"]>;
-        message: Schema.SchemaClass<string, string, never>;
-    }>]>>;
+    tooltip: Schema.optional<Schema.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
     hidden: Schema.optional<Schema.SchemaClass<boolean, boolean, never>>;
     id: Schema.refine<string, typeof Schema.String>;
     groupId: Schema.optional<typeof Schema.UUID>;
@@ -61,13 +85,19 @@ export declare function registerRowVariablesIfAbsent(env: Environment): void;
 export declare function CelRowAccess(configure: (env: Environment) => void, options?: {
     resultType?: ResultType;
 }): Schema.Schema<string, string, never>;
-export declare function LocaleMarkdownWithRow(configure: (env: Environment) => void): Schema.filter<Schema.TupleType<readonly [Schema.Struct<{
-    locale: Schema.Literal<["zh"]>;
-    message: Schema.SchemaClass<string, string, never>;
-}>], [Schema.Struct<{
-    locale: Schema.Literal<["ja", "en", "ko"]>;
-    message: Schema.SchemaClass<string, string, never>;
-}>]>>;
+export declare function LocaleMarkdownWithRow(configure: (env: Environment) => void): Schema.filter<Schema.suspend<readonly [{
+    readonly locale: "zh";
+    readonly message: string;
+}, ...{
+    readonly locale: "en" | "ja" | "ko";
+    readonly message: string;
+}[]], string | readonly [{
+    readonly locale: "zh";
+    readonly message: string;
+}, ...{
+    readonly locale: "en" | "ja" | "ko";
+    readonly message: string;
+}[]], never>>;
 export declare function derivedRowField(configure: (env: Environment) => void, resultType: ResultType): Schema.optional<Schema.Struct<{
     mode: Schema.Literal<["formula", "prefill"]>;
     expression: Schema.Schema<string, string, never>;