kloudy-mcp 0.1.0-beta.0

package/dist/api-x/projections.js

@@ -0,0 +1,790 @@
+import { z } from 'zod';
+const translatedTextSchema = z.record(z.string()).catch({});
+const optionalString = z.string().optional();
+const optionalNumber = z.number().optional();
+const paginationSchema = z.object({
+    total: z.number().int().nonnegative(),
+    currentPage: z.number().int().positive(),
+    pageSize: z.number().int().positive(),
+    totalPages: z.number().int().nonnegative(),
+});
+const movieSchema = z.object({
+    movieId: z.string().min(1),
+    title: optionalString,
+    titleI18n: translatedTextSchema.optional().default({}),
+    introI18n: translatedTextSchema.optional().default({}),
+    coverUrl: optionalString,
+    rate: optionalNumber,
+    publishDate: optionalString,
+    type: optionalString,
+    region: optionalString,
+});
+const gameSchema = z.object({
+    gameId: z.string().min(1),
+    title: optionalString,
+    titleI18n: translatedTextSchema.optional().default({}),
+    introI18n: translatedTextSchema.optional().default({}),
+    coverUrl: optionalString,
+    rate: optionalNumber,
+    publishDate: optionalString,
+    region: optionalString,
+    gameplay: optionalString,
+});
+function projectPagination(value) {
+    return paginationSchema.parse(value);
+}
+function projectMovieSummary(value) {
+    const item = movieSchema.parse(value);
+    const projected = {
+        movieId: item.movieId,
+        titleI18n: item.titleI18n,
+    };
+    if (item.title !== undefined)
+        projected.title = item.title;
+    if (item.coverUrl !== undefined)
+        projected.coverUrl = item.coverUrl;
+    if (item.rate !== undefined)
+        projected.rate = item.rate;
+    if (item.publishDate !== undefined)
+        projected.publishDate = item.publishDate;
+    if (item.type !== undefined)
+        projected.type = item.type;
+    if (item.region !== undefined)
+        projected.region = item.region;
+    return projected;
+}
+export function projectMovieDetail(value) {
+    const item = movieSchema.parse(value);
+    return { ...projectMovieSummary(item), introI18n: item.introI18n };
+}
+function projectGameSummary(value) {
+    const item = gameSchema.parse(value);
+    const projected = {
+        gameId: item.gameId,
+        titleI18n: item.titleI18n,
+    };
+    if (item.title !== undefined)
+        projected.title = item.title;
+    if (item.coverUrl !== undefined)
+        projected.coverUrl = item.coverUrl;
+    if (item.rate !== undefined)
+        projected.rate = item.rate;
+    if (item.publishDate !== undefined)
+        projected.publishDate = item.publishDate;
+    if (item.region !== undefined)
+        projected.region = item.region;
+    if (item.gameplay !== undefined)
+        projected.gameplay = item.gameplay;
+    return projected;
+}
+export function projectGameDetail(value) {
+    const item = gameSchema.parse(value);
+    return { ...projectGameSummary(item), introI18n: item.introI18n };
+}
+export function projectMovieSearch(value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return { list: response.list.map(projectMovieSummary), pagination: projectPagination(response.pagination) };
+}
+export function projectGameSearch(value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return { list: response.list.map(projectGameSummary), pagination: projectPagination(response.pagination) };
+}
+const actorCharacterSchema = z.object({
+    characterId: z.string().min(1),
+    characterType: z.string().min(1),
+    name: z.string().nullish(),
+});
+const capabilitiesSchema = z.object({
+    contractVersion: z.number().int().positive(),
+    actor: z.object({
+        authType: z.enum(['visitor', 'guest', 'user']),
+        permissionLevel: z.number().int().nonnegative(),
+        permission: z.enum(['visitor', 'guest', 'user', 'admin']),
+        character: actorCharacterSchema.nullable(),
+    }),
+    availableModules: z.array(z.string()),
+    availableArchiveTypes: z.array(z.enum(['movie', 'game', 'song', 'activity', 'product'])),
+    permissions: z.record(z.boolean()),
+    featureFlags: z.record(z.boolean()),
+});
+export function projectCapabilities(value) {
+    const parsed = capabilitiesSchema.parse(value);
+    return {
+        ...parsed,
+        actor: {
+            ...parsed.actor,
+            character: parsed.actor.character
+                ? {
+                    characterId: parsed.actor.character.characterId,
+                    characterType: parsed.actor.character.characterType,
+                    ...(parsed.actor.character.name ? { name: parsed.actor.character.name } : {}),
+                }
+                : null,
+        },
+    };
+}
+const accountContextSchema = z.object({
+    authType: z.enum(['visitor', 'guest', 'user']).optional().default('visitor'),
+    permissionLevel: z.number().int().nonnegative(),
+    user: z.object({ userId: z.string().min(1) }).nullish(),
+    character: z
+        .object({
+        characterId: z.string().min(1),
+        characterType: z.string().min(1),
+        name: z.string().nullish(),
+        avatarUrl: z.string().nullish(),
+    })
+        .nullish(),
+});
+export function projectAccountContext(value) {
+    const parsed = accountContextSchema.parse(value);
+    return {
+        authType: parsed.authType,
+        permissionLevel: parsed.permissionLevel,
+        user: parsed.user ? { userId: parsed.user.userId } : null,
+        character: parsed.character
+            ? {
+                characterId: parsed.character.characterId,
+                characterType: parsed.character.characterType,
+                ...(parsed.character.name ? { name: parsed.character.name } : {}),
+                ...(parsed.character.avatarUrl ? { avatarUrl: parsed.character.avatarUrl } : {}),
+            }
+            : null,
+    };
+}
+const ownedCharacterSchema = z.object({
+    characterId: z.string().min(1),
+    characterType: z.string().min(1),
+    name: z.string().nullish(),
+    avatarUrl: z.string().nullish(),
+});
+export function projectOwnedCharacters(value) {
+    return z.array(ownedCharacterSchema).parse(value).map((character) => ({
+        characterId: character.characterId,
+        characterType: character.characterType,
+        ...(character.name ? { name: character.name } : {}),
+        ...(character.avatarUrl ? { avatarUrl: character.avatarUrl } : {}),
+    }));
+}
+const assetOverviewSchema = z.object({
+    points: z.object({
+        balance: z.number().int(),
+        totalEarned: z.number().int(),
+        totalSpent: z.number().int(),
+    }),
+    medalCount: z.number().int().nonnegative(),
+    assetCount: z.number().int().nonnegative(),
+});
+export function projectAssetOverview(value) {
+    return assetOverviewSchema.parse(value);
+}
+const ownedAssetSchema = z.object({
+    assetId: z.string().min(1),
+    assetType: z.string().min(1),
+    name: z.string(),
+    description: z.string().nullish(),
+    iconUrl: z.string().nullish(),
+    quantity: z.number().int(),
+    expireAt: z.string().nullish(),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+});
+export function projectOwnedAssets(value) {
+    const response = z.object({ list: z.array(ownedAssetSchema), pagination: z.unknown() }).parse(value);
+    return {
+        list: response.list.map((asset) => ({
+            assetId: asset.assetId,
+            assetType: asset.assetType,
+            name: asset.name,
+            ...(asset.description ? { description: asset.description } : {}),
+            ...(asset.iconUrl ? { iconUrl: asset.iconUrl } : {}),
+            quantity: asset.quantity,
+            ...(asset.expireAt ? { expireAt: asset.expireAt } : {}),
+            ...(asset.createTime ? { createTime: asset.createTime } : {}),
+            ...(asset.updateTime ? { updateTime: asset.updateTime } : {}),
+        })),
+        pagination: projectPagination(response.pagination),
+    };
+}
+const publicCharacterSchema = z.object({
+    characterId: z.string().min(1),
+    characterType: z.string().min(1),
+    name: z.string().nullish(),
+    avatarUrl: z.string().nullish(),
+    intro: z.string().nullish(),
+    birthday: z.string().nullish(),
+    color: z.string().nullish(),
+    websiteUrl: z.string().nullish(),
+    profileVisibility: z.string().nullish(),
+    visibleModules: z.array(z.string()).optional().default([]),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+});
+function projectPublicCharacterValue(value) {
+    const character = publicCharacterSchema.parse(value);
+    return {
+        characterId: character.characterId,
+        characterType: character.characterType,
+        ...(character.name ? { name: character.name } : {}),
+        ...(character.avatarUrl ? { avatarUrl: character.avatarUrl } : {}),
+        ...(character.intro ? { intro: character.intro } : {}),
+        ...(character.birthday ? { birthday: character.birthday } : {}),
+        ...(character.color ? { color: character.color } : {}),
+        ...(character.websiteUrl ? { websiteUrl: character.websiteUrl } : {}),
+        ...(character.profileVisibility ? { profileVisibility: character.profileVisibility } : {}),
+        visibleModules: character.visibleModules,
+        ...(character.createTime ? { createTime: character.createTime } : {}),
+        ...(character.updateTime ? { updateTime: character.updateTime } : {}),
+    };
+}
+export function projectCharacterSearch(value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return {
+        list: response.list.map(projectPublicCharacterValue),
+        pagination: projectPagination(response.pagination),
+    };
+}
+export function projectCharacter(value) {
+    return projectPublicCharacterValue(value);
+}
+const tagAttributeSchema = z.object({
+    attr_id: z.string().min(1),
+    category: z.string().nullish(),
+    weight: z.number().optional().default(0),
+    name: z.string().min(1),
+    name_i18n: translatedTextSchema.optional().default({}),
+    description_i18n: translatedTextSchema.optional().default({}),
+});
+function projectTagAttributeValue(value) {
+    const attribute = tagAttributeSchema.parse(value);
+    return {
+        attributeId: attribute.attr_id,
+        ...(attribute.category ? { category: attribute.category } : {}),
+        weight: attribute.weight,
+        name: attribute.name,
+        nameI18n: attribute.name_i18n,
+        descriptionI18n: attribute.description_i18n,
+    };
+}
+export function projectTagAttributes(value) {
+    return z.array(z.unknown()).parse(value).map(projectTagAttributeValue);
+}
+export function projectTagAttribute(value) {
+    return value === null ? null : projectTagAttributeValue(value);
+}
+const tagDefinitionSchema = z.object({
+    tag_id: z.string().min(1),
+    attr_id: z.string().min(1),
+    tag_name: z.string().min(1),
+    tag_name_i18n: translatedTextSchema.optional().default({}),
+    tag_description_i18n: translatedTextSchema.optional().default({}),
+    attr_name: z.string().min(1),
+    attr_name_i18n: translatedTextSchema.optional().default({}),
+    color: z.string().nullish(),
+    weight: z.number().optional().default(0),
+    tag_weight: z.number().optional(),
+});
+function projectTagDefinitionValue(value) {
+    const tag = tagDefinitionSchema.parse(value);
+    return {
+        tagKey: tag.tag_id,
+        attributeId: tag.attr_id,
+        name: tag.tag_name,
+        nameI18n: tag.tag_name_i18n,
+        descriptionI18n: tag.tag_description_i18n,
+        attributeName: tag.attr_name,
+        attributeNameI18n: tag.attr_name_i18n,
+        ...(tag.color ? { color: tag.color } : {}),
+        tagWeight: tag.tag_weight ?? tag.weight,
+        ...(tag.tag_weight !== undefined ? { resourceWeight: tag.weight } : {}),
+    };
+}
+export function projectTags(value) {
+    return z.array(z.unknown()).parse(value).map(projectTagDefinitionValue);
+}
+export function projectTag(value) {
+    return value === null ? null : projectTagDefinitionValue(value);
+}
+const metadataFieldSchema = z.object({
+    field_id: z.string().min(1),
+    field_type: z.string().min(1),
+    category: z.string().nullish(),
+    icon: z.string().nullish(),
+    name: z.string().min(1),
+    name_i18n: translatedTextSchema.optional().default({}),
+    description: z.string().nullish(),
+    description_i18n: translatedTextSchema.optional().default({}),
+    weight: z.number().optional().default(0),
+});
+function projectMetadataFieldValue(value) {
+    const field = metadataFieldSchema.parse(value);
+    return {
+        fieldId: field.field_id,
+        fieldType: field.field_type,
+        ...(field.category ? { category: field.category } : {}),
+        ...(field.icon ? { icon: field.icon } : {}),
+        name: field.name,
+        nameI18n: field.name_i18n,
+        ...(field.description ? { description: field.description } : {}),
+        descriptionI18n: field.description_i18n,
+        weight: field.weight,
+    };
+}
+export function projectMetadataFields(value) {
+    return z.array(z.unknown()).parse(value).map(projectMetadataFieldValue);
+}
+const resourceMetadataSchema = z.object({
+    field_id: z.string().min(1),
+    field_type: z.string().min(1),
+    field_name: z.string().min(1),
+    field_name_i18n: translatedTextSchema.optional().default({}),
+    category: z.string().nullish(),
+    icon: z.string().nullish(),
+    value: z.string(),
+    parsed_value: z.unknown(),
+});
+export function projectResourceMetadata(value) {
+    return z.array(resourceMetadataSchema).parse(value).map((item) => ({
+        fieldId: item.field_id,
+        fieldType: item.field_type,
+        fieldName: item.field_name,
+        fieldNameI18n: item.field_name_i18n,
+        ...(item.category ? { category: item.category } : {}),
+        ...(item.icon ? { icon: item.icon } : {}),
+        value: item.value,
+        parsedValue: item.parsed_value,
+    }));
+}
+export function projectRelationRoles(value) {
+    return z
+        .array(z.object({ role_id: z.string().min(1), category: z.string().min(1) }))
+        .parse(value)
+        .map((role) => ({ roleId: role.role_id, category: role.category }));
+}
+const publicLinkSchema = z.object({
+    linkSn: z.string().min(1),
+    classId: z.string().nullish(),
+    weight: z.number().nullish(),
+    disabled: z.number().int().nullish(),
+    title: z.string().nullish(),
+    intro: z.string().nullish(),
+    icon: z.string().nullish(),
+    url: z.string().nullish(),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+});
+export function projectPublicLinks(value) {
+    return z.array(publicLinkSchema).parse(value).map((item) => ({
+        linkSn: item.linkSn,
+        ...(item.classId ? { classId: item.classId } : {}),
+        ...(item.weight !== null && item.weight !== undefined ? { weight: item.weight } : {}),
+        disabled: item.disabled !== null && item.disabled !== undefined ? item.disabled > 0 : false,
+        ...(item.title ? { title: item.title } : {}),
+        ...(item.intro ? { intro: item.intro } : {}),
+        ...(item.icon ? { icon: item.icon } : {}),
+        ...(item.url ? { url: item.url } : {}),
+        ...(item.createTime ? { createTime: item.createTime } : {}),
+        ...(item.updateTime ? { updateTime: item.updateTime } : {}),
+    }));
+}
+const archiveCarouselSchema = z.object({
+    title: z.string(),
+    subtitle: z.string(),
+    imageUrl: z.string(),
+    isDark: z.number().int(),
+    link: z.string(),
+});
+export function projectArchiveCarousel(value) {
+    return z.array(archiveCarouselSchema).parse(value).map((item) => ({
+        title: item.title,
+        subtitle: item.subtitle,
+        imageUrl: item.imageUrl,
+        isDark: item.isDark > 0,
+        link: item.link,
+    }));
+}
+const documentSpaceSchema = z.object({
+    spaceId: z.string().min(1),
+    spaceType: z.string().min(1),
+    ownerCharacterId: z.string().nullish(),
+    name: z.string().nullish(),
+    accessType: z.enum(['public', 'owner']),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+});
+export function projectDocumentSpace(value) {
+    const space = documentSpaceSchema.parse(value);
+    return {
+        spaceId: space.spaceId,
+        spaceType: space.spaceType,
+        accessType: space.accessType,
+        ...(space.ownerCharacterId ? { ownerCharacterId: space.ownerCharacterId } : {}),
+        ...(space.name ? { name: space.name } : {}),
+        ...(space.createTime ? { createTime: space.createTime } : {}),
+        ...(space.updateTime ? { updateTime: space.updateTime } : {}),
+    };
+}
+export function projectDocumentSpaces(value) {
+    return z.array(z.unknown()).parse(value).map(projectDocumentSpace);
+}
+export function projectDocumentDirectory(value) {
+    const directory = z
+        .object({
+        name: z.string(),
+        type: z.literal('directory'),
+        children: z
+            .array(z.object({
+            path: z.string().min(1),
+            type: z.enum(['file', 'directory']),
+            size: z.number().int().nonnegative().optional(),
+        }))
+            .optional()
+            .default([]),
+    })
+        .parse(value);
+    return {
+        name: directory.name,
+        children: directory.children.map((entry) => ({
+            path: entry.path,
+            type: entry.type,
+            ...(entry.size !== undefined ? { size: entry.size } : {}),
+        })),
+    };
+}
+const communityPostSchema = z.object({
+    postId: z.string().min(1),
+    postLink: z.string().min(1),
+    title: z.string().nullish(),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+});
+function projectCommunityPostValue(value) {
+    const post = communityPostSchema.parse(value);
+    return {
+        postId: post.postId,
+        postLink: post.postLink,
+        ...(post.title ? { title: post.title } : {}),
+        ...(post.createTime ? { createTime: post.createTime } : {}),
+        ...(post.updateTime ? { updateTime: post.updateTime } : {}),
+    };
+}
+export function projectCommunityPost(value) {
+    return value === null ? null : projectCommunityPostValue(value);
+}
+export function projectCommunityPosts(value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return {
+        list: response.list.map(projectCommunityPostValue),
+        pagination: projectPagination(response.pagination),
+    };
+}
+const communityCharacterSchema = z.object({
+    characterId: z.string().nullish(),
+    characterType: z.string().nullish(),
+    name: z.string().nullish(),
+    avatarUrl: z.string().nullish(),
+});
+const communityCommentSchema = z.lazy(() => z.object({
+    commentSn: z.string().min(1),
+    content: z.string().nullish(),
+    md: z.number().nullish(),
+    character: communityCharacterSchema.nullish(),
+    post: z.unknown().optional(),
+    parent: communityCommentSchema.optional(),
+    children: z.array(communityCommentSchema).optional(),
+    isMine: z.boolean(),
+    canDelete: z.boolean(),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+}));
+function projectCommunityComment(value) {
+    const comment = communityCommentSchema.parse(value);
+    return {
+        commentSn: comment.commentSn,
+        ...(comment.content !== undefined && comment.content !== null ? { content: comment.content } : {}),
+        ...(comment.md !== undefined && comment.md !== null ? { md: comment.md } : {}),
+        ...(comment.character
+            ? {
+                character: {
+                    ...(comment.character.characterId ? { characterId: comment.character.characterId } : {}),
+                    ...(comment.character.characterType ? { characterType: comment.character.characterType } : {}),
+                    ...(comment.character.name ? { name: comment.character.name } : {}),
+                    ...(comment.character.avatarUrl ? { avatarUrl: comment.character.avatarUrl } : {}),
+                },
+            }
+            : {}),
+        ...(comment.post ? { post: projectCommunityPostValue(comment.post) } : {}),
+        ...(comment.parent ? { parent: projectCommunityComment(comment.parent) } : {}),
+        ...(comment.children ? { children: comment.children.map(projectCommunityComment) } : {}),
+        isMine: comment.isMine,
+        canDelete: comment.canDelete,
+        ...(comment.createTime ? { createTime: comment.createTime } : {}),
+        ...(comment.updateTime ? { updateTime: comment.updateTime } : {}),
+    };
+}
+export function projectCommunityComments(value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return {
+        list: response.list.map(projectCommunityComment),
+        pagination: projectPagination(response.pagination),
+    };
+}
+const communityMessageSchema = z.object({
+    messageSn: z.string().min(1),
+    isRead: z.number().nullish(),
+    msgType: z.string().nullish(),
+    msgTitle: z.string(),
+    msgContent: z.string().nullish(),
+    contentType: z.string().nullish(),
+    msgLink: z.string().nullish(),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+});
+export function projectCommunityMessages(value) {
+    const response = z.object({ list: z.array(communityMessageSchema), pagination: z.unknown() }).parse(value);
+    return {
+        list: response.list.map((message) => ({
+            messageSn: message.messageSn,
+            ...(message.isRead !== undefined && message.isRead !== null ? { isRead: message.isRead } : {}),
+            ...(message.msgType ? { messageType: message.msgType } : {}),
+            title: message.msgTitle,
+            ...(message.msgContent ? { content: message.msgContent } : {}),
+            ...(message.contentType ? { contentType: message.contentType } : {}),
+            ...(message.msgLink ? { link: message.msgLink } : {}),
+            ...(message.createTime ? { createTime: message.createTime } : {}),
+            ...(message.updateTime ? { updateTime: message.updateTime } : {}),
+        })),
+        pagination: projectPagination(response.pagination),
+    };
+}
+export function projectCommunityMessageCount(value) {
+    return z.number().int().nonnegative().parse(value);
+}
+export function projectCommunityCommentCreate(value) {
+    const result = z.object({ commentSn: z.string().regex(/^[A-Za-z0-9]{9}$/) }).parse(value);
+    return { commentSn: result.commentSn };
+}
+export function projectBooleanMutation(value) {
+    return z.boolean().parse(value);
+}
+const genericArchiveSchema = z.object({
+    movieId: z.string().min(1).optional(),
+    gameId: z.string().min(1).optional(),
+    songId: z.string().min(1).optional(),
+    activityId: z.string().min(1).optional(),
+    productId: z.string().min(1).optional(),
+    title: z.string().nullish(),
+    intro: z.string().nullish(),
+    titleI18n: translatedTextSchema.optional().default({}),
+    introI18n: translatedTextSchema.optional().default({}),
+    coverUrl: z.string().nullish(),
+    rate: z.number().nullish(),
+    publishDate: z.string().nullish(),
+    releaseDate: z.string().nullish(),
+    region: z.string().nullish(),
+    gameplay: z.string().nullish(),
+    brand: z.string().nullish(),
+    category: z.string().nullish(),
+    activityType: z.string().nullish(),
+    location: z.string().nullish(),
+    city: z.string().nullish(),
+    startDate: z.string().nullish(),
+    endDate: z.string().nullish(),
+});
+function archiveIdForType(item, resourceType) {
+    const itemId = {
+        movie: item.movieId,
+        game: item.gameId,
+        song: item.songId,
+        activity: item.activityId,
+        product: item.productId,
+    }[resourceType];
+    if (!itemId)
+        throw new z.ZodError([]);
+    return itemId;
+}
+function projectArchiveItem(resourceType, value, includeIntro) {
+    const item = genericArchiveSchema.parse(value);
+    const projected = {
+        resourceType,
+        itemId: archiveIdForType(item, resourceType),
+        titleI18n: item.titleI18n,
+    };
+    const stringFields = [
+        'title',
+        'coverUrl',
+        'publishDate',
+        'releaseDate',
+        'region',
+        'gameplay',
+        'brand',
+        'category',
+        'activityType',
+        'location',
+        'city',
+        'startDate',
+        'endDate',
+    ];
+    for (const field of stringFields) {
+        const fieldValue = item[field];
+        if (typeof fieldValue === 'string')
+            projected[field] = fieldValue;
+    }
+    if (typeof item.rate === 'number')
+        projected.rate = item.rate;
+    if (includeIntro) {
+        if (typeof item.intro === 'string')
+            projected.intro = item.intro;
+        projected.introI18n = item.introI18n;
+    }
+    return projected;
+}
+export function projectArchiveSearch(resourceType, value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return {
+        list: response.list.map((item) => projectArchiveItem(resourceType, item, false)),
+        pagination: projectPagination(response.pagination),
+    };
+}
+export function projectArchiveDetail(resourceType, value) {
+    return projectArchiveItem(resourceType, value, true);
+}
+const blogCharacterSchema = z.object({
+    characterId: z.string().min(1),
+    characterType: z.string().nullish(),
+    name: z.string().nullish(),
+    avatarUrl: z.string().nullish(),
+});
+const blogArticleSchema = z.object({
+    articleId: z.string().min(1),
+    title: z.string().nullish(),
+    intro: z.string().nullish(),
+    coverUrl: z.string().nullish(),
+    articleType: z.string().nullish(),
+    category: z.string().nullish(),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+    content: z.string().optional(),
+    assetBaseUrl: z.string().optional(),
+    character: blogCharacterSchema.optional(),
+    children: z.array(z.unknown()).optional(),
+});
+function projectBlogArticle(value) {
+    const article = blogArticleSchema.parse(value);
+    return {
+        articleId: article.articleId,
+        ...(article.title ? { title: article.title } : {}),
+        ...(article.intro ? { intro: article.intro } : {}),
+        ...(article.coverUrl ? { coverUrl: article.coverUrl } : {}),
+        ...(article.articleType ? { articleType: article.articleType } : {}),
+        ...(article.category ? { category: article.category } : {}),
+        ...(article.createTime ? { createTime: article.createTime } : {}),
+        ...(article.updateTime ? { updateTime: article.updateTime } : {}),
+        ...(article.content !== undefined ? { content: article.content } : {}),
+        ...(article.assetBaseUrl !== undefined ? { assetBaseUrl: article.assetBaseUrl } : {}),
+        ...(article.character
+            ? {
+                character: {
+                    characterId: article.character.characterId,
+                    ...(article.character.characterType ? { characterType: article.character.characterType } : {}),
+                    ...(article.character.name ? { name: article.character.name } : {}),
+                    ...(article.character.avatarUrl ? { avatarUrl: article.character.avatarUrl } : {}),
+                },
+            }
+            : {}),
+        ...(article.children ? { children: article.children.map(projectBlogArticle) } : {}),
+    };
+}
+export function projectBlogList(value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return { list: response.list.map(projectBlogArticle), pagination: projectPagination(response.pagination) };
+}
+export function projectBlogDetail(value) {
+    return projectBlogArticle(value);
+}
+const blogHeadlineSchema = z.object({
+    title: z.string().nullish(),
+    subtitle: z.string().nullish(),
+    intro: z.string().nullish(),
+    color: z.string().nullish(),
+    img: z.string().nullish(),
+    title_img: z.string().nullish(),
+    dark_mode: z.enum(['auto', 'dark', 'light', '']).nullish(),
+    gray: z.number().int().nullish(),
+    v_align: z.number().int().nullish(),
+    h_align: z.number().int().nullish(),
+    create_time: z.string().nullish(),
+    update_time: z.string().nullish(),
+});
+export function projectBlogHeadlines(value) {
+    return z.array(blogHeadlineSchema).parse(value).map((item) => ({
+        ...(item.title ? { title: item.title } : {}),
+        ...(item.subtitle ? { subtitle: item.subtitle } : {}),
+        ...(item.intro ? { intro: item.intro } : {}),
+        ...(item.color ? { color: item.color } : {}),
+        ...(item.img ? { imageUrl: item.img } : {}),
+        ...(item.title_img ? { titleImageUrl: item.title_img } : {}),
+        ...(item.dark_mode !== null && item.dark_mode !== undefined ? { darkMode: item.dark_mode } : {}),
+        grayscale: item.gray !== null && item.gray !== undefined ? item.gray > 0 : false,
+        ...(item.v_align !== null && item.v_align !== undefined ? { verticalAlign: item.v_align } : {}),
+        ...(item.h_align !== null && item.h_align !== undefined ? { horizontalAlign: item.h_align } : {}),
+        ...(item.create_time ? { createTime: item.create_time } : {}),
+        ...(item.update_time ? { updateTime: item.update_time } : {}),
+    }));
+}
+const ownedBlogArticleSchema = z.object({
+    articleId: z.string().min(1),
+    title: z.string().nullish(),
+    intro: z.string().nullish(),
+    coverUrl: z.string().nullish(),
+    articleType: z.string().nullish(),
+    category: z.string().nullish(),
+    isPublished: z.number().int().min(0).max(1).optional().default(0),
+    createTime: z.string().nullish(),
+    updateTime: z.string().nullish(),
+});
+function projectOwnedBlogArticle(value) {
+    const article = ownedBlogArticleSchema.parse(value);
+    return {
+        articleId: article.articleId,
+        ...(article.title ? { title: article.title } : {}),
+        ...(article.intro ? { intro: article.intro } : {}),
+        ...(article.coverUrl ? { coverUrl: article.coverUrl } : {}),
+        ...(article.articleType ? { articleType: article.articleType } : {}),
+        ...(article.category ? { category: article.category } : {}),
+        isPublished: article.isPublished === 1,
+        ...(article.createTime ? { createTime: article.createTime } : {}),
+        ...(article.updateTime ? { updateTime: article.updateTime } : {}),
+    };
+}
+export function projectOwnedBlogArticles(value) {
+    const response = z.object({ list: z.array(z.unknown()), pagination: z.unknown() }).parse(value);
+    return {
+        list: response.list.map(projectOwnedBlogArticle),
+        pagination: projectPagination(response.pagination),
+    };
+}
+export function projectBlogDraft(value) {
+    const draft = z
+        .object({
+        article: z.unknown(),
+        content: z.string(),
+        formalContent: z.string(),
+        draftContent: z.string(),
+        hasDraft: z.boolean(),
+        canEditDraft: z.boolean(),
+    })
+        .parse(value);
+    return {
+        article: { ...projectOwnedBlogArticle(draft.article), canEditDraft: draft.canEditDraft },
+        content: draft.content,
+        formalContent: draft.formalContent,
+        draftContent: draft.draftContent,
+        hasDraft: draft.hasDraft,
+    };
+}
+export function projectBlogDraftContent(value) {
+    const content = z.object({ articleId: z.string().min(1), content: z.string() }).parse(value);
+    return { articleId: content.articleId, content: content.content };
+}
+//# sourceMappingURL=projections.js.map