nolo-cli 0.1.23 → 0.1.29

package/create/space/content/updateContentCategoryAction.ts

@@ -0,0 +1,154 @@
+// 文件路径: create/space/actions/updateContentCategoryAction.ts (或你的实际路径)
+
+import type { SpaceId } from "../../space/types"; // 确认类型路径
+import type { SpaceData } from "../../../app/types";
+import { selectUserId } from "../../../auth/authSlice"; // 确认导入路径
+import { createSpaceKey } from "../../space/spaceKeys"; // 确认导入路径
+import { read, patch } from "../../../database/dbSlice"; // 确认导入路径
+import type { AppDispatch, RootState } from "../../../app/store"; // 假设 store 类型路径
+import { checkSpaceMembership } from "../utils/permissions"; // 导入权限检查函数
+// --- 导入常量 ---
+import { UNCATEGORIZED_ID } from "../../space/constants"; // 导入代表 UI 未分类容器的常量
+
+/**
+ * 异步 Action Thunk，用于更新指定内容的分类。
+ * - 如果目标是未分类区域 (通过 UNCATEGORIZED_ID 标识)，则移除内容的 categoryId 属性。
+ * - 如果目标是有效分类，则设置内容的 categoryId 为该分类 ID。
+ */
+export const updateContentCategoryAction = async (
+  // --- 修改: 输入类型明确为 string，代表目标容器 ID ---
+  //   这个 ID 可以是真实的分类 ID，也可以是 UNCATEGORIZED_ID 常量
+  input: { spaceId: SpaceId; contentKey: string; categoryId: string },
+  thunkAPI: { dispatch: AppDispatch; getState: () => RootState } // 使用明确类型
+): Promise<{ spaceId: SpaceId; updatedSpaceData: SpaceData }> => {
+  // --- 重命名 categoryId 为 targetContainerId 以更清晰地表达其含义 ---
+  const { spaceId, contentKey, categoryId: targetContainerId } = input;
+  const { dispatch, getState } = thunkAPI;
+  const state = getState();
+  const userId = selectUserId(state);
+
+  // --- 基本输入验证 ---
+  if (!userId) {
+    throw new Error("User is not logged in.");
+  }
+  if (
+    !contentKey ||
+    typeof contentKey !== "string" ||
+    contentKey.trim() === ""
+  ) {
+    throw new Error("Invalid contentKey provided.");
+  }
+  // targetContainerId 必须是字符串 (普通分类 ID 或 UNCATEGORIZED_ID)
+  if (typeof targetContainerId !== "string") {
+    // 如果允许 null/undefined，需要调整类型和后续逻辑
+    // 但基于拖拽目标通常是字符串 ID，这里强制为 string
+    throw new Error("Invalid target container ID provided (must be a string).");
+  }
+
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData: SpaceData | null = null;
+  try {
+    spaceData = await dispatch(read({
+      dbKey: spaceKey
+    })).unwrap();
+  } catch (readError: any) {
+    console.error(
+      `[updateContentCategoryAction] Failed to read space data for key ${spaceKey}:`,
+      readError
+    );
+    throw new Error(
+      `无法加载空间数据: ${spaceId}, 原因: ${readError.message || "未知错误"}`
+    );
+  }
+
+  // --- 权限和存在性检查 ---
+  try {
+    checkSpaceMembership(spaceData, userId); // 使用权限检查函数
+  } catch (permissionError: any) {
+    throw new Error(`权限不足，无法修改内容分类: ${permissionError.message}`);
+  }
+
+  const currentContent = spaceData?.contents?.[contentKey]; // 获取当前内容
+  if (!currentContent) {
+    console.warn(
+      `[updateContentCategoryAction] Content ${contentKey} not found in space ${spaceId}.`
+    );
+    throw new Error("Content not found");
+  }
+
+  // --- 检查目标分类的有效性 (如果不是移到未分类) ---
+  // 仅当目标不是 UNCATEGORIZED_ID 常量时，才需要验证目标分类是否存在
+  if (targetContainerId !== UNCATEGORIZED_ID) {
+    if (!spaceData.categories?.[targetContainerId]) {
+      // 目标分类不存在或无效 (值为 null)
+      console.warn(
+        `[updateContentCategoryAction] Target category ${targetContainerId} not found or invalid in space ${spaceId}. Cannot move content.`
+      );
+      throw new Error("Target category not found or is invalid");
+      // 也可以选择不抛错，直接忽略本次操作，但抛错更明确
+    }
+    // 如果目标分类有效，则继续
+  }
+  // 如果目标是 UNCATEGORIZED_ID，则无需检查分类是否存在
+
+  // --- 构造 Patch Changes 对象 (核心修改) ---
+  const now = Date.now(); // 使用 number 时间戳
+
+  // 1. 确定要在 patch 中使用的 categoryId 值
+  //    - 如果目标是未分类容器，使用 null 指令来删除属性
+  //    - 否则，使用目标容器 ID (也就是目标分类 ID)
+  const categoryIdValueForPatch =
+    targetContainerId === UNCATEGORIZED_ID ? null : targetContainerId;
+
+  // 2. 检查内容当前的 categoryId 是否真的需要改变
+  //    - 获取当前内容的 categoryId (可能是 undefined)
+  const currentCategoryId = currentContent.categoryId;
+  //    - 比较目标 patch 值与当前值
+  //    - 注意: 如果当前是 undefined 且目标 patch 值是 null，也视为不需要改变（已经是未分类）
+  let needsUpdate = true;
+  if (categoryIdValueForPatch === null && currentCategoryId === undefined) {
+    needsUpdate = false; // 已经是未分类，无需发送 patch 删除指令
+  } else if (categoryIdValueForPatch === currentCategoryId) {
+    needsUpdate = false; // 目标分类与当前分类相同
+  }
+
+  // 3. 如果确实需要更新，才构造 changes 对象
+  let changes: Partial<Pick<SpaceData, "contents" | "updatedAt">> | null = null; // 初始化为 null
+  if (needsUpdate) {
+    changes = {
+      contents: {
+        // 使用动态键更新指定的 contentKey
+        [contentKey]: {
+          // --- 修改: 使用计算出的 categoryIdValueForPatch ---
+          categoryId: categoryIdValueForPatch, // null 或 目标分类 ID
+          updatedAt: now, // 更新内容的 updatedAt
+        },
+      },
+      updatedAt: now, // 更新顶层的 updatedAt
+    };
+  } else {
+    console.log(
+      `[updateContentCategoryAction] No category change needed for ${contentKey}. Skipping patch.`
+    );
+    // 如果不需要更新，直接返回当前数据即可
+    return { spaceId, updatedSpaceData: spaceData };
+  }
+
+  // --- 执行 Patch 更新 (仅在需要更新时执行) ---
+  let updatedSpaceData: SpaceData;
+  try {
+    // 只有当 changes 不为 null 时才 dispatch patch
+    updatedSpaceData = await dispatch(
+      patch({ dbKey: spaceKey, changes: changes! }) // 使用非空断言，因为已检查
+    ).unwrap();
+  } catch (patchError: any) {
+    console.error(
+      `[updateContentCategoryAction] Failed to patch space data for key ${spaceKey}:`,
+      patchError
+    );
+    throw new Error(`更新内容分类失败: ${patchError.message || "未知错误"}`);
+  }
+
+  // --- 返回结果 ---
+  return { spaceId, updatedSpaceData };
+};

package/create/space/content/updateContentTitleAction.ts

@@ -0,0 +1,106 @@
+import type { SpaceContent, SpaceData, ULID } from "../../../app/types";
+import { createSpaceKey } from "../../space/spaceKeys";
+import { read, patch } from "../../../database/dbSlice";
+import { renameTable } from "../../../render/table/tableSlice";
+import { SEPARATOR } from "../../../database/keys";
+
+
+export const updateContentTitleAction = async (
+  input: {
+    spaceId: ULID;
+    contentKey: string;
+    title: string;
+    skillSummary?: SpaceContent["skillSummary"];
+    sourceServerOrigin?: string | null;
+  },
+  thunkAPI: any
+): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+  const { spaceId, contentKey, title, skillSummary, sourceServerOrigin } = input;
+  const { dispatch } = thunkAPI;
+
+  if (
+    !contentKey ||
+    typeof contentKey !== "string" ||
+    contentKey.trim() === ""
+  ) {
+    throw new Error("Invalid contentKey provided.");
+  }
+  if (title === undefined || title === null || typeof title !== "string") {
+    throw new Error("Invalid title provided.");
+  }
+  if (title.trim() === "") {
+    throw new Error("Title cannot be empty.");
+  }
+
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData: SpaceData | null = null;
+  try {
+    spaceData = await dispatch(read({
+      dbKey: spaceKey,
+      preferredServerOrigin: sourceServerOrigin,
+    })).unwrap();
+  } catch (readError) {
+    throw new Error(`无法加载空间数据: ${spaceId}`);
+  }
+
+  if (!spaceData) {
+    throw new Error("Space not found");
+  }
+
+  if (!spaceData.contents || !spaceData.contents[contentKey]) {
+    throw new Error("Content not found in space");
+  }
+
+  const now = new Date().toISOString();
+
+  const changes = {
+    contents: {
+      [contentKey]: {
+        ...spaceData.contents[contentKey],
+        title: title.trim(),
+        updatedAt: now,
+        ...(skillSummary !== undefined ? { skillSummary } : {}),
+      },
+    },
+    updatedAt: now,
+  };
+
+  let updatedSpaceData: SpaceData;
+  try {
+    updatedSpaceData = await dispatch(
+      patch({
+        dbKey: spaceKey,
+        changes,
+        preferredServerOrigin: sourceServerOrigin,
+      })
+    ).unwrap();
+  } catch (patchError: any) {
+    throw new Error(`更新内容标题失败: ${patchError.message || "未知错误"}`);
+  }
+
+
+  // If it's a table, also sync with TableMeta
+  if (contentKey.startsWith("meta-")) {
+    const parts = contentKey.split(SEPARATOR);
+    if (parts.length >= 3) {
+      const tableId = parts[parts.length - 1];
+      const tenantId = parts.slice(1, parts.length - 1).join(SEPARATOR);
+
+      try {
+        await dispatch(
+          renameTable({
+            tenantId,
+            tableId,
+            newName: title.trim(),
+          })
+        ).unwrap();
+      } catch (tableError) {
+        console.error("Failed to sync title to TableMeta:", tableError);
+        // We don't throw here to avoid failing the whole space update
+      }
+    }
+  }
+
+  return { spaceId, updatedSpaceData };
+
+};

package/create/space/content/uploadAndAddFileToSpaceAction.ts

@@ -0,0 +1,98 @@
+
+import { ContentType, SpaceData } from "../../../app/types";
+import { uploadFileAction } from "../../../database/actions/upload";
+import { addContentAction } from "./addContentAction";
+import { toast } from "../../../app/utils/toast";
+import { resolveFileCategory } from "../../../app/utils/fileUtils";
+import { ulid } from "../../../database/utils/ulid";
+import { fileKey } from "../../../database/keys";
+import { selectUserId } from "../../../auth/authSlice";
+import { patch } from "../../../database/dbSlice";
+
+interface UploadAndAddFileToSpacePayload {
+    spaceId: string;
+    file: File;
+    categoryId?: string;
+}
+
+export const uploadAndAddFileToSpaceAction = async (
+    payload: UploadAndAddFileToSpacePayload,
+    thunkAPI: any
+): Promise<{ spaceId: string; updatedSpaceData: SpaceData; contentKey: string; fileId: string }> => {
+    const { spaceId, file, categoryId } = payload;
+    const { dispatch, getState } = thunkAPI;
+
+    // UserId retrieved from auth state
+    const state = getState();
+    const userId = selectUserId(state);
+
+    if (!userId) {
+        console.warn("[uploadAndAddFileToSpace] Warning: No userId found in state. Uploading as anonymous/unknown might cause issues.");
+    }
+
+    try {
+        // 生成一个确保唯一的 Key (file-userId-ulid)
+        const id = ulid();
+        const dbKey = fileKey.single(userId || "unknown", id);
+        const contentType = ContentType.FILE;
+        const fileCategory = resolveFileCategory({
+            mimeType: file.type,
+            fileName: file.name,
+        });
+
+        // 执行上传；uploadFileAction 当前只接受 file/customKey/userId。
+        const fileMetadata = await uploadFileAction(
+            { file, customKey: dbKey, userId },
+            thunkAPI
+        );
+
+        // 2. 添加到 Space Content
+        if (!fileMetadata) {
+            throw new Error("Upload failed, no metadata returned");
+        }
+
+        // 使用返回的 dbKey (file-userId-ulid) 作为 contentKey
+        const contentKey = fileMetadata.dbKey || dbKey;
+        const title = file.name;
+
+        // addContentAction is a raw async function, NOT a Redux action creator.
+        // It expects (payload, thunkAPI).
+        const result = await addContentAction({
+            spaceId,
+            contentKey,
+            title,
+            type: contentType,
+            fileCategory,
+            mimeType: file.type || undefined,
+            fileSize: Number.isFinite(file.size) ? file.size : undefined,
+            originalName: file.name,
+            categoryId,
+        }, thunkAPI);
+
+        await (dispatch as any)(
+            patch({
+                dbKey: contentKey,
+                changes: {
+                    title,
+                    spaceId,
+                    fileCategory,
+                    mimeType: file.type || undefined,
+                    fileSize: Number.isFinite(file.size) ? file.size : undefined,
+                    originalName: file.name,
+                },
+            })
+        ).unwrap();
+
+        if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("nolo-user-data-updated"));
+        }
+
+        toast.success("文件上传成功");
+        return { ...result, contentKey, fileId: fileMetadata.id };
+
+    } catch (error: any) {
+        console.error("Upload and add file error:", error);
+        toast.error(error.message || "上传文件失败");
+        throw error;
+    }
+};

package/create/space/contentKeyUtils.ts

@@ -0,0 +1,117 @@
+import { ContentType } from "../../app/types";
+import { buildAppEditorPath } from "../../app/constants/appEditor";
+import { DataType } from "../types";
+import { normalizeSpaceId } from "./spaceKeys";
+
+const ROUTABLE_KEY_PREFIXES = [
+  "dialog-",
+  "page-",
+  "meta-",
+  "file-",
+  "image-",
+  "agent-",
+  "cybot-",
+  "task-",
+] as const;
+
+const hasRoutablePrefix = (contentKey: string): boolean =>
+  ROUTABLE_KEY_PREFIXES.some((prefix) => contentKey.startsWith(prefix));
+
+export const isAppContentKey = (contentKey: string): boolean =>
+  typeof contentKey === "string" && contentKey.startsWith("app-");
+
+export const normalizeAppRouteId = (contentKey: string): string =>
+  isAppContentKey(contentKey) ? contentKey : `app-${contentKey}`;
+
+export const resolveRoutableContentKey = (
+  contentKey: string,
+  type?: string,
+  userId?: string
+): string => {
+  if (!contentKey) return contentKey;
+
+  const normalizedType = type?.toLowerCase();
+
+  if (normalizedType === ContentType.APP || normalizedType === "app") {
+    return normalizeAppRouteId(contentKey);
+  }
+
+  if (hasRoutablePrefix(contentKey)) return contentKey;
+  if (!userId) return contentKey;
+
+  if (normalizedType === DataType.DIALOG || normalizedType === ContentType.DIALOG) {
+    return `${DataType.DIALOG}-${userId}-${contentKey}`;
+  }
+
+  if (normalizedType === DataType.DOC || normalizedType === ContentType.DOC) {
+    return `${DataType.DOC}-${userId}-${contentKey}`;
+  }
+
+  // 文件和图片的 dbKey 统一使用 file-{userId}-{fileId} 格式
+  if (normalizedType === DataType.FILE || normalizedType === ContentType.FILE ||
+      normalizedType === DataType.IMAGE || normalizedType === ContentType.IMAGE) {
+    return `file-${userId}-${contentKey}`;
+  }
+
+  return contentKey;
+};
+
+export const buildScopedPagePath = (
+  pageKey: string,
+  spaceId?: string | null
+): string => {
+  if (!spaceId) return `/${pageKey}`;
+  return `/space/${normalizeSpaceId(spaceId)}/${pageKey}`;
+};
+
+export const buildRoutableContentPath = ({
+  contentKey,
+  type,
+  userId,
+  spaceId,
+}: {
+  contentKey: string;
+  type?: string;
+  userId?: string;
+  spaceId?: string | null;
+}): string =>
+  buildScopedPagePath(
+    resolveRoutableContentKey(contentKey, type, userId),
+    spaceId
+  );
+
+export const isRoutableContentActive = ({
+  contentKey,
+  type,
+  userId,
+  spaceId,
+  activePageKey,
+  currentPath,
+}: {
+  contentKey: string;
+  type?: string;
+  userId?: string | null;
+  spaceId?: string | null;
+  activePageKey?: string;
+  currentPath: string;
+}): boolean => {
+  const routeContentKey = resolveRoutableContentKey(
+    contentKey,
+    type,
+    userId ?? undefined
+  );
+
+  if (activePageKey === contentKey || activePageKey === routeContentKey) {
+    return true;
+  }
+
+  if (
+    type?.toLowerCase() === ContentType.APP ||
+    isAppContentKey(contentKey)
+  ) {
+    const appEditorPath = buildAppEditorPath(normalizeAppRouteId(contentKey), spaceId);
+    return currentPath === appEditorPath;
+  }
+
+  return false;
+};

package/create/space/contentLabels.ts

@@ -0,0 +1,56 @@
+import type { TFunction } from "i18next";
+import { ContentType, type FileCategory, type SpaceContent } from "../../app/types";
+
+export const getFileCategoryLabel = (
+  category: FileCategory | undefined,
+  t: TFunction
+): string => {
+  switch (category) {
+    case "image":
+      return t("images", "图片");
+    case "document":
+      return t("documentAttachment", "文档附件");
+    case "video":
+      return t("videoAttachment", "视频");
+    case "audio":
+      return t("audioAttachment", "音频");
+    default:
+      return t("attachment", "附件");
+  }
+};
+
+export const getSpaceContentTypeLabel = (
+  item: Pick<SpaceContent, "type" | "contentKey" | "fileCategory">,
+  t: TFunction
+): string => {
+  const type = item.type?.toLowerCase();
+  const key = item.contentKey || "";
+
+  if (type === ContentType.DIALOG || key.startsWith("dialog-")) {
+    return t("dialogs", "对话");
+  }
+  if (type === ContentType.DOC || key.startsWith("page-")) {
+    return t("pages", "文档");
+  }
+  if (type === "table" || key.startsWith("meta-")) {
+    return t("tables", "表格");
+  }
+  if (type === ContentType.APP || key.startsWith("app-")) {
+    return t("apps", "应用");
+  }
+  if (
+    type === ContentType.IMAGE ||
+    key.startsWith("image-") ||
+    item.fileCategory === "image"
+  ) {
+    return t("images", "图片");
+  }
+  if (type === ContentType.AGENT || type === "cybot" || key.startsWith("agent-") || key.startsWith("cybot-")) {
+    return t("agents", "AI");
+  }
+  if (type === ContentType.FILE) {
+    return getFileCategoryLabel(item.fileCategory, t);
+  }
+
+  return type || t("content", "内容");
+};

package/create/space/contentTypeMeta.ts

@@ -0,0 +1,169 @@
+import type { IconType } from "react-icons";
+import {
+  LuBot,
+  LuCalendarClock,
+  LuAudioLines,
+  LuFile,
+  LuFileText,
+  LuFolderOpen,
+  LuGrid2X2,
+  LuImage,
+  LuLayoutGrid,
+  LuMessageSquare,
+  LuVideo,
+} from "react-icons/lu";
+
+import type { ContentTab } from "../../app/utils/myContentItems";
+import type { SidebarVisibleType } from "./sidebarVisibleTypes";
+
+type SharedContentTypeId =
+  | Extract<
+      ContentTab,
+      "all" | "app" | "agent" | "dialog" | "page" | "image" | "document" | "video" | "audio" | "table" | "file"
+    >
+  | "scheduled";
+
+export interface ContentTypeMeta {
+  id: SharedContentTypeId;
+  icon: IconType;
+  shortLabelKey: string;
+  shortDefaultLabel: string;
+  titleKey?: string;
+  defaultTitle?: string;
+  sidebarType?: SidebarVisibleType;
+}
+
+export const CONTENT_TYPE_META: Record<SharedContentTypeId, ContentTypeMeta> = {
+  all: {
+    id: "all",
+    icon: LuFolderOpen,
+    shortLabelKey: "all",
+    shortDefaultLabel: "全部",
+    titleKey: "homeTabs.myContent",
+    defaultTitle: "我的内容",
+  },
+  app: {
+    id: "app",
+    icon: LuLayoutGrid,
+    shortLabelKey: "apps",
+    shortDefaultLabel: "应用",
+    titleKey: "homeTabs.myApps",
+    defaultTitle: "我的应用",
+    sidebarType: "app",
+  },
+  agent: {
+    id: "agent",
+    icon: LuBot,
+    shortLabelKey: "agents",
+    shortDefaultLabel: "AI",
+    titleKey: "homeTabs.myAgents",
+    defaultTitle: "我的 AI",
+    sidebarType: "agent",
+  },
+  dialog: {
+    id: "dialog",
+    icon: LuMessageSquare,
+    shortLabelKey: "dialogs",
+    shortDefaultLabel: "对话",
+    titleKey: "homeTabs.myDialogs",
+    defaultTitle: "我的对话",
+    sidebarType: "dialog",
+  },
+  page: {
+    id: "page",
+    icon: LuFileText,
+    shortLabelKey: "pages",
+    shortDefaultLabel: "文档",
+    titleKey: "homeTabs.myDocs",
+    defaultTitle: "我的文档",
+    sidebarType: "page",
+  },
+  image: {
+    id: "image",
+    icon: LuImage,
+    shortLabelKey: "images",
+    shortDefaultLabel: "图片",
+    titleKey: "homeTabs.myImages",
+    defaultTitle: "我的图片",
+    sidebarType: "image",
+  },
+  document: {
+    id: "document",
+    icon: LuFileText,
+    shortLabelKey: "documentAttachments",
+    shortDefaultLabel: "文档附件",
+    titleKey: "homeTabs.myDocumentAttachments",
+    defaultTitle: "我的文档附件",
+    sidebarType: "document",
+  },
+  video: {
+    id: "video",
+    icon: LuVideo,
+    shortLabelKey: "videos",
+    shortDefaultLabel: "视频",
+    titleKey: "homeTabs.myVideos",
+    defaultTitle: "我的视频",
+    sidebarType: "video",
+  },
+  audio: {
+    id: "audio",
+    icon: LuAudioLines,
+    shortLabelKey: "audios",
+    shortDefaultLabel: "音频",
+    titleKey: "homeTabs.myAudios",
+    defaultTitle: "我的音频",
+    sidebarType: "audio",
+  },
+  table: {
+    id: "table",
+    icon: LuGrid2X2,
+    shortLabelKey: "tables",
+    shortDefaultLabel: "表格",
+    titleKey: "homeTabs.myTables",
+    defaultTitle: "我的表格",
+    sidebarType: "table",
+  },
+  file: {
+    id: "file",
+    icon: LuFile,
+    shortLabelKey: "files",
+    shortDefaultLabel: "附件",
+    titleKey: "homeTabs.myFiles",
+    defaultTitle: "我的附件",
+  },
+  scheduled: {
+    id: "scheduled",
+    icon: LuCalendarClock,
+    shortLabelKey: "scheduled",
+    shortDefaultLabel: "定时",
+    sidebarType: "scheduled",
+  },
+};
+
+export const MY_CONTENT_TYPE_META = [
+  CONTENT_TYPE_META.all,
+  CONTENT_TYPE_META.app,
+  CONTENT_TYPE_META.agent,
+  CONTENT_TYPE_META.dialog,
+  CONTENT_TYPE_META.page,
+  CONTENT_TYPE_META.image,
+  CONTENT_TYPE_META.document,
+  CONTENT_TYPE_META.video,
+  CONTENT_TYPE_META.audio,
+  CONTENT_TYPE_META.table,
+  CONTENT_TYPE_META.file,
+] as const;
+
+export const CHAT_SIDEBAR_TYPE_META = [
+  CONTENT_TYPE_META.dialog,
+  CONTENT_TYPE_META.page,
+  CONTENT_TYPE_META.image,
+  CONTENT_TYPE_META.document,
+  CONTENT_TYPE_META.video,
+  CONTENT_TYPE_META.audio,
+  CONTENT_TYPE_META.file,
+  CONTENT_TYPE_META.table,
+  CONTENT_TYPE_META.app,
+  CONTENT_TYPE_META.agent,
+  CONTENT_TYPE_META.scheduled,
+] as const;