@purpleschool/gptbot 0.8.58 → 0.8.59

package/models/community/community-post-media-data.schema.ts

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { COMMUNITY_POST_TYPE, IMAGE_FORMAT } from '../../constants';
+import { MusicTrackSchema } from '../tools/music/music-track.schema';
+import { VideoJobParamsSchema } from '../tools/video/video-job.schema';
+import { FileSchema } from '../file.schema';
+import { MusicJobParamsSchema } from '../tools';
+
+export const ImageCommunityMediaSchema = z.object({
+    type: z.literal(COMMUNITY_POST_TYPE.IMAGE),
+    text: z.string().max(10000),
+    files: z.array(FileSchema.pick({ url: true })),
+    imageFormat: z.nativeEnum(IMAGE_FORMAT).nullable(),
+});
+
+export const ImageEditorCommunityMediaSchema = z.object({
+    type: z.literal(COMMUNITY_POST_TYPE.IMAGE_EDITOR),
+    prompt: z.string(),
+    imageUrls: z.array(z.string()).nullable(),
+});
+
+export const VideoCommunityMediaSchema = z.object({
+    type: z.literal(COMMUNITY_POST_TYPE.VIDEO),
+    title: z.string(),
+    prompt: z.string(),
+    videoUrl: z.string().nullable(),
+    params: VideoJobParamsSchema,
+});
+
+export const VideoEditorCommunityMediaSchema = z.object({
+    type: z.literal(COMMUNITY_POST_TYPE.VIDEO_EDITOR),
+    title: z.string(),
+    prompt: z.string(),
+    inputVideoUrl: z.string(),
+    outputVideoUrl: z.string().nullable(),
+});
+
+export const MusicCommunityMediaSchema = z.object({
+    type: z.literal(COMMUNITY_POST_TYPE.MUSIC),
+    params: MusicJobParamsSchema,
+    prompt: z.string(),
+    tracks: z.array(
+        MusicTrackSchema.pick({
+            audioUrl: true,
+            coverUrl: true,
+            duration: true,
+            title: true,
+            tags: true,
+        }),
+    ),
+});
+
+export const CommunityPostMediaDataSchema = z.discriminatedUnion('type', [
+    ImageCommunityMediaSchema,
+    ImageEditorCommunityMediaSchema,
+    VideoCommunityMediaSchema,
+    VideoEditorCommunityMediaSchema,
+    MusicCommunityMediaSchema,
+]);
+
+export type CommunityPostMediaData = z.infer<typeof CommunityPostMediaDataSchema>;
+export type ImageCommunityMedia = z.infer<typeof ImageCommunityMediaSchema>;
+export type ImageEditorCommunityMedia = z.infer<typeof ImageEditorCommunityMediaSchema>;
+export type VideoCommunityMedia = z.infer<typeof VideoCommunityMediaSchema>;
+export type VideoEditorCommunityMedia = z.infer<typeof VideoEditorCommunityMediaSchema>;
+export type MusicCommunityMedia = z.infer<typeof MusicCommunityMediaSchema>;

package/models/community/community-post-report/community-post-report.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { COMMUNITY_POST_REPORT_REASON } from '../../../constants';
+
+export const CommunityPostReportSchema = z.object({
+    uuid: z.string().uuid(),
+    communityPostId: z.string().uuid(),
+    userId: z.string().uuid(),
+    reason: z.nativeEnum(COMMUNITY_POST_REPORT_REASON),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/community/community-post-report/index.ts

@@ -0,0 +1 @@
+export * from './community-post-report.schema';

package/models/community/community-post.schema.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import {
+    COMMUNITY_POST_STATUS,
+    COMMUNITY_POST_TYPE,
+    COMMUNITY_POST_VISIBILITY,
+    COMMUNITY_TOOL_TYPE,
+} from '../../constants';
+import { CommunityPostMediaDataSchema } from './community-post-media-data.schema';
+import { IconVariantsSchema } from '../icon-variants.schema';
+
+export const CommunityPostSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    caption: z.string().nullable(),
+    status: z.nativeEnum(COMMUNITY_POST_STATUS),
+    visibility: z.nativeEnum(COMMUNITY_POST_VISIBILITY),
+    type: z.nativeEnum(COMMUNITY_POST_TYPE),
+    mediaData: CommunityPostMediaDataSchema,
+    aiModelId: z.string().uuid(),
+    aiModelTitle: z.string(),
+    aiModelIcons: IconVariantsSchema,
+    messageId: z.string().nullable(),
+    toolJobId: z.string().nullable(),
+    toolType: z.nativeEnum(COMMUNITY_TOOL_TYPE).nullable(),
+    views: z.number(),
+    likesCount: z.number(),
+    reportsCount: z.number(),
+    publishedAt: z.date().nullable(),
+    archivedAt: z.date().nullable(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export const ResponseCommunityPostSchema = z.object({
+    uuid: z.string().uuid(),
+    userId: z.string().uuid(),
+    caption: z.string().nullable(),
+    status: z.nativeEnum(COMMUNITY_POST_STATUS),
+    visibility: z.nativeEnum(COMMUNITY_POST_VISIBILITY),
+    type: z.nativeEnum(COMMUNITY_POST_TYPE),
+    mediaData: CommunityPostMediaDataSchema,
+    aiModelId: z.string().uuid(),
+    aiModelTitle: z.string(),
+    aiModelIcons: IconVariantsSchema,
+    views: z.number(),
+    likesCount: z.number(),
+    publishedAt: z.date().nullable(),
+});

package/models/community/index.ts

@@ -0,0 +1,3 @@
+export * from './community-post.schema';
+export * from './community-post-media-data.schema';
+export * from './community-post-report';

package/models/index.ts

@@ -55,3 +55,5 @@ export * from './webmaster-balance.schema';
 export * from './user-referrals.schema';
 export * from './webmaster-click.schema';
 export * from './api-key.schema';
+export * from './community';
+export * from './user-profile.schema';

package/models/order.schema.ts

@@ -8,6 +8,7 @@ export const OrderSchema = z.object({
     productId: z.nullable(z.string().uuid()),
     subscriptionId: z.nullable(z.string().uuid()),
     sum: z.number(),
+    description: z.string(),
 
     createdAt: z.date(),
     updatedAt: z.date(),

package/models/page.schema.ts

@@ -13,7 +13,8 @@ export const PageSchema = z.object({
     aIModelId: z.string().uuid().nullable().optional(),
     toolId: z.string().uuid().nullable().optional(),
     toolOptionId: z.string().uuid().nullable().optional(),
-    toolTitle: z.string().nullable(),
+    toolModelId: z.string().uuid().nullable().optional(),
+    toolTitle: z.string().optional().nullable(),
     type: z.nativeEnum(PageType),
 
     createdAt: z.date(),

package/models/payment.schema.ts

@@ -3,10 +3,14 @@ import { z } from 'zod';
 export const PaymentSchema = z.object({
     uuid: z.string().uuid(),
     link: z.nullable(z.string()),
-    status: z.boolean(),
+    status: z.string(),
     sum: z.number(),
     orderId: z.string().uuid(),
 
     createdAt: z.date(),
     updatedAt: z.date(),
 });
+
+export const PaymentWithDescriptionSchema = PaymentSchema.extend({
+    description: z.string(),
+});

package/models/review.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { REVIEW_STATUS } from '../constants';
 
 export const ReviewSchema = z.object({
     uuid: z.string().uuid(),
@@ -6,6 +7,7 @@ export const ReviewSchema = z.object({
     name: z.string(),
     text: z.string(),
     rating: z.number().int().step(1).min(0).max(5),
+    status: z.nativeEnum(REVIEW_STATUS),
 
     createdAt: z.date(),
     updatedAt: z.date(),

package/models/subscription-feature.schema.ts

@@ -162,6 +162,36 @@ export const MusicModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.exten
 });
 export type MusicModelAccessFeature = z.infer<typeof MusicModelAccessFeatureSchema>;
 
+export const WriterQuotaFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.WRITER),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.WRITER_QUOTA),
+    value: z.number(),
+});
+export type WriterQuotaFeature = z.infer<typeof WriterQuotaFeatureSchema>;
+
+export const WriterModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.WRITER),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.WRITER_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type WriterModelAccessFeature = z.infer<typeof WriterModelAccessFeatureSchema>;
+
+export const ImageEditorQuotaFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.IMAGE_EDITOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.IMAGE_EDITOR_QUOTA),
+    value: z.number(),
+});
+export type ImageEditorQuotaFeature = z.infer<typeof ImageEditorQuotaFeatureSchema>;
+
+export const ImageEditorModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.IMAGE_EDITOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.IMAGE_EDITOR_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type ImageEditorModelAccessFeature = z.infer<typeof ImageEditorModelAccessFeatureSchema>;
+
 export const SubscriptionFeatureSchema = z.union([
     AiModelAccessFeatureSchema,
     RequestsQuotaFeatureSchema,
@@ -181,6 +211,10 @@ export const SubscriptionFeatureSchema = z.union([
     CarryoverBalanceFeatureSchema,
     MusicQuotaFeatureSchema,
     MusicModelAccessFeatureSchema,
+    WriterQuotaFeatureSchema,
+    WriterModelAccessFeatureSchema,
+    ImageEditorQuotaFeatureSchema,
+    ImageEditorModelAccessFeatureSchema,
 ]);
 
 export type SubscriptionFeature = z.infer<typeof SubscriptionFeatureSchema>;

package/models/tool.schema.ts

@@ -6,6 +6,9 @@ export const ToolSchema = z.object({
     title: z.string(),
     description: z.string(),
     icon: z.string(),
+    alias: z.string(),
+    bgColor: z.string(),
+    iconColor: z.string(),
     order: z.number(),
     contentType: z.string(),
 });

package/models/tools/common/attached-tool-file.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const AttachedToolFileSchema = z.object({
+    uuid: z.string(),
+    url: z.string(),
+    name: z.string(),
+    mimeType: z.string(),
+    type: z.string(),
+    size: z.number(),
+    duration: z.number().optional().nullable(),
+});
+
+export type AttachedToolFile = z.infer<typeof AttachedToolFileSchema>;

package/models/tools/common/index.ts

@@ -0,0 +1 @@
+export * from './attached-tool-file.schema';

package/models/tools/image-editor/image-editor-config.schema.ts

@@ -27,6 +27,7 @@ export const SystemPromptSchema = z.object({
         .optional()
         .nullable(),
     order: z.number(),
+    placeholder: z.string().nullable(),
 });
 
 export const PromptGroupSchema = z.object({

package/models/tools/image-editor/image-editor-job.schema.ts

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 import { USER_REACTION } from '../../../constants';
 import { ToolJobSchema } from '../../tool-job.schema';
+import { FileSchema } from '../../file.schema';
+import { AttachedToolFileSchema } from '../common';
 
 export const ImageEditorJobParamsSchema = z.object({
-    imageUrls: z.array(z.string()).optional(),
+    attachedFiles: z.array(AttachedToolFileSchema),
     systemPromptId: z.string().optional(),
+    imageUrls: z.string().array().optional(),
 });
 
 export type ImageEditorJobParams = z.infer<typeof ImageEditorJobParamsSchema>;
@@ -13,7 +16,15 @@ export const ImageEditorJobSchema = ToolJobSchema.extend({
     title: z.string(),
     prompt: z.string(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
-    imageUrls: z.array(z.string()).nullable(),
+    imageUrls: z.string().array(),
+    images: z
+        .array(
+            FileSchema.pick({
+                uuid: true,
+                url: true,
+            }),
+        )
+        .nullable(),
     params: ImageEditorJobParamsSchema,
     modelId: z.string(),
 });

package/models/tools/image-editor/image-editor-model.schema.ts

@@ -12,6 +12,21 @@ export const ImageEditorModelParamsSchema = z.object({
 
 export type ImageEditorModelParams = z.infer<typeof ImageEditorModelParamsSchema>;
 
+export const ImageEditorModelPricingRuleConditionSchema = z.object({
+    withoutSub: z.boolean().optional(),
+});
+export type ImageEditorModelPricingRuleCondition = z.infer<
+    typeof ImageEditorModelPricingRuleConditionSchema
+>;
+
+export const ImageEditorModelPricingRulesSchema = z.array(
+    z.object({
+        condition: ImageEditorModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type ImageEditorModelPricingRules = z.infer<typeof ImageEditorModelPricingRulesSchema>;
+
 export const ImageEditorModelSchema = z.object({
     uuid: z.string(),
     title: z.string(),
@@ -21,6 +36,7 @@ export const ImageEditorModelSchema = z.object({
     icons: IconVariantsSchema,
     maxInputLength: z.number(),
     params: ImageEditorModelParamsSchema,
+    pricingRules: ImageEditorModelPricingRulesSchema,
     unlockedBy: UnlockedBySchema.nullable(),
     canUse: z.boolean(),
 });

package/models/tools/image-generation/image-generation-config.schema.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { ImageGenerationModelSchema } from './image-generation-model.schema';
+import { IconVariantsSchema } from '../../icon-variants.schema';
+
+export const ImageGenerationVendorSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    order: z.number(),
+    icons: IconVariantsSchema,
+    models: z.array(ImageGenerationModelSchema),
+});
+
+export type ImageGenerationVendor = z.infer<typeof ImageGenerationVendorSchema>;
+
+export const ImageGenerationPresetSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    sample: z.string(),
+    order: z.number(),
+});
+
+export type ImageGenerationPreset = z.infer<typeof ImageGenerationPresetSchema>;
+
+export const ImageGenerationConfigSchema = z.object({
+    vendors: z.array(ImageGenerationVendorSchema),
+    presets: z.array(ImageGenerationPresetSchema),
+});
+
+export type ImageGenerationConfig = z.infer<typeof ImageGenerationConfigSchema>;

package/models/tools/image-generation/image-generation-job.schema.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { ToolJobSchema } from '../../tool-job.schema';
+import { IMAGE_GENERATION_RESOLUTION, USER_REACTION } from '../../../constants';
+
+export const ImageGenerationFileAttachmentSchema = z.object({
+    uuid: z.string(),
+    url: z.string(),
+    name: z.string(),
+    type: z.string(),
+    mimeType: z.string(),
+    size: z.number(),
+});
+export type ImageGenerationFileAttachment = z.infer<typeof ImageGenerationFileAttachmentSchema>;
+
+export const ImageGenerationJobParamsSchema = z.object({
+    aspectRatio: z.string().optional(),
+    attachedFiles: z.array(ImageGenerationFileAttachmentSchema),
+    enhancePrompt: z.boolean().optional(),
+    resolution: z.nativeEnum(IMAGE_GENERATION_RESOLUTION).optional(),
+});
+
+export type ImageGenerationJobParams = z.infer<typeof ImageGenerationJobParamsSchema>;
+
+export const ImageGenerationJobSchema = ToolJobSchema.extend({
+    title: z.string(),
+    prompt: z.string(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    presetId: z.string().uuid().nullable().optional(),
+    output: z.array(z.string()).nullable(),
+    images: z
+        .array(
+            z.object({
+                uuid: z.string(),
+                url: z.string(),
+            }),
+        )
+        .nullable(),
+    params: ImageGenerationJobParamsSchema.optional(),
+    modelId: z.string(),
+});
+
+export type ImageGenerationJob = z.infer<typeof ImageGenerationJobSchema>;

package/models/tools/image-generation/image-generation-model.schema.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { UnlockedBySchema } from '../../unlocked-by-subscription.schema';
+import { IMAGE_GENERATION_RESOLUTION } from '../../../constants';
+
+export const ImageGenerationModelParamsSchema = z.object({
+    aspectRatio: z.record(
+        z.string(),
+        z.object({
+            width: z.number(),
+            height: z.number(),
+        }),
+    ),
+    quality: z.string().optional(),
+    resolution: z
+        .object({
+            options: z.array(z.nativeEnum(IMAGE_GENERATION_RESOLUTION)),
+        })
+        .optional(),
+});
+export type ImageGenerationModelParams = z.infer<typeof ImageGenerationModelParamsSchema>;
+
+export const ImageModelPricingRuleConditionSchema = z.object({
+    resolution: z.string().optional(),
+    withoutSub: z.boolean().optional(),
+});
+export type ImageModelPricingRuleCondition = z.infer<typeof ImageModelPricingRuleConditionSchema>;
+
+export const ImageModelPricingRulesSchema = z.array(
+    z.object({
+        condition: ImageModelPricingRuleConditionSchema,
+        value: z.number(),
+    }),
+);
+export type ImageModelPricingRules = z.infer<typeof ImageModelPricingRulesSchema>;
+
+export const ImageGenerationModelSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    description: z.string(),
+    order: z.number(),
+    status: z.string(),
+    price: z.number(),
+    params: ImageGenerationModelParamsSchema,
+    supportsImageAttachment: z.boolean(),
+    maxAttachedImages: z.number(),
+    maxPromptLength: z.number(),
+    pricingRules: ImageModelPricingRulesSchema,
+    unlockedBy: UnlockedBySchema.nullable(),
+    canUse: z.boolean(),
+});
+
+export type ImageGenerationModel = z.infer<typeof ImageGenerationModelSchema>;

package/models/tools/image-generation/index.ts

@@ -0,0 +1,3 @@
+export * from './image-generation-config.schema';
+export * from './image-generation-job.schema';
+export * from './image-generation-model.schema';

package/models/tools/index.ts

@@ -1,3 +1,4 @@
+export * from './common';
 export * from './language';
 export * from './paraphrase';
 export * from './presentation';
@@ -8,3 +9,4 @@ export * from './writer';
 export * from './image-editor';
 export * from './video-editor';
 export * from './music';
+export * from './image-generation';

package/models/tools/music/music-track.schema.ts

@@ -6,6 +6,7 @@ export const MusicTrackSchema = z.object({
     audioId: z.string(),
     audioUrl: z.string(),
     coverUrl: z.string(),
+    prompt: z.string().nullable(),
     tags: z.string(),
     duration: z.number(),
 

package/models/tools/paraphrase/paraphrase-job.schema.ts

@@ -1,9 +1,14 @@
 import { z } from 'zod';
 import { ToolJobSchema } from '../../tool-job.schema';
+import { PARAPHRASING_INTENSITY, USER_REACTION } from '../../../constants';
 
 export const ParaphraseToolJobSchema = ToolJobSchema.extend({
     styleId: z.string().uuid().nullable().optional(),
     modelId: z.string().uuid().nullable().optional(),
     userInput: z.string(),
+    title: z.string(),
+    typeId: z.string(),
+    intensity: z.nativeEnum(PARAPHRASING_INTENSITY),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
     aiOutput: z.string().nullable().optional(),
 });

package/models/tools/presentation/pptx-export-payload.schema.ts

@@ -5,8 +5,22 @@ export enum PPTX_SHAPE_TYPE {
     PICTURE_BOX = 'picture_box',
     CUSTOM_SHAPE = 'custom_shape',
     TABLE = 'table',
+    CHEVRON = 'chevron',
 }
 
+export enum PPTX_CHEVRON_DIRECTION {
+    RIGHT = 'right',
+    LEFT = 'left',
+    UP = 'up',
+    DOWN = 'down',
+}
+
+export enum PPTX_ARROW_TYPE {
+    RIGHT = 'rightArrow',
+    LEFT = 'leftArrow',
+    UP = 'upArrow',
+    DOWN = 'downArrow',
+}
 export enum PPTX_H_ALIGN {
     LEFT = 'left',
     CENTER = 'center',
@@ -182,6 +196,25 @@ export const PPTXTableShapeSchema = z.object({
 });
 export type PPTXTableShape = z.infer<typeof PPTXTableShapeSchema>;
 
+// Chevron
+export const PPTXChevronShapeSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.CHEVRON),
+    direction: z.nativeEnum(PPTX_CHEVRON_DIRECTION).default(PPTX_CHEVRON_DIRECTION.RIGHT),
+    position: PPTXPositionSchema,
+    fill: PPTXFillSchema.optional(),
+    text: z.string().optional(),
+    font: PPTXFontSchema.optional(),
+    align: z
+        .nativeEnum(PPTX_H_ALIGN)
+        .optional()
+        .default('center' as PPTX_H_ALIGN),
+    valign: z
+        .nativeEnum(PPTX_V_ALIGN)
+        .optional()
+        .default('middle' as PPTX_V_ALIGN),
+});
+export type PPTXChevronShape = z.infer<typeof PPTXChevronShapeSchema>;
+
 // Overview
 
 export const PPTXShapeSchema = z.discriminatedUnion('type', [
@@ -189,6 +222,7 @@ export const PPTXShapeSchema = z.discriminatedUnion('type', [
     PPTXPictureBoxSchema,
     PPTXCustomShapeSchema,
     PPTXTableShapeSchema,
+    PPTXChevronShapeSchema,
 ]);
 export type PPTXShape = z.infer<typeof PPTXShapeSchema>;
 

package/models/tools/presentation/slide-content-edit.schema.ts

@@ -12,6 +12,7 @@ import {
     IBarChartSlideDataStructure,
     IChartSlideDataStructure,
     ImageSlotSchema,
+    ITimelineSlideDataStructure,
 } from './slide-content.schema';
 import { SLIDE_CONTENT_TYPE } from '../../../constants';
 
@@ -140,6 +141,25 @@ export const ChartSlideDataUserEditSchema = z.object({
     version: z.literal(1),
 }) satisfies z.ZodType<IChartSlideDataStructure>;
 
+export const TimelineSlideDataUserEditSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TIMELINE),
+    title: z.string().min(1).max(500),
+    description: z.string().min(1).max(1000),
+    timeline: z.object({
+        events: z
+            .array(
+                z.object({
+                    date: z.string().min(1).max(100),
+                    title: z.string().min(1).max(200),
+                    description: z.string().min(1).max(500),
+                }),
+            )
+            .min(2)
+            .max(10),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITimelineSlideDataStructure>;
+
 export const SlideContentUserEditSchema = z.discriminatedUnion('contentType', [
     CoverSlideDataUserEditSchema,
     StructuredListSlideDataUserEditSchema,
@@ -150,5 +170,6 @@ export const SlideContentUserEditSchema = z.discriminatedUnion('contentType', [
     ThankYouSlideDataUserEditSchema,
     TableSlideDataUserEditSchema,
     ChartSlideDataUserEditSchema,
+    TimelineSlideDataUserEditSchema,
 ]);
 export type SlideContentUserEdit = z.infer<typeof SlideContentUserEditSchema>;

package/models/tools/presentation/slide-content.schema.ts

@@ -108,6 +108,20 @@ export interface IChartSlideDataStructure {
     version: 1;
 }
 
+export interface ITimelineSlideDataStructure {
+    contentType: SLIDE_CONTENT_TYPE.TIMELINE;
+    title: string;
+    description: string;
+    timeline: {
+        events: Array<{
+            date: string;
+            title: string;
+            description: string;
+        }>;
+    };
+    version: 1;
+}
+
 export const CoverSlideDataSchema = z.object({
     contentType: z.literal(SLIDE_CONTENT_TYPE.COVER),
     title: z.string().describe('Slide title in about 6 words').min(10).max(150),
@@ -307,6 +321,36 @@ export const ChartSlideDataSchema = z.object({
 }) satisfies z.ZodType<IChartSlideDataStructure>;
 export type ChartSlideData = z.infer<typeof ChartSlideDataSchema>;
 
+export const TimelineSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TIMELINE),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(150),
+    description: z.string().describe('Brief context for the timeline').min(10).max(200),
+    timeline: z.object({
+        events: z
+            .array(
+                z.object({
+                    date: z
+                        .string()
+                        .describe(
+                            'Date or time period label. MUST be general/approximate if exact date unknown (e.g., "Early 2020s", "Mid-1990s", "Recent years")',
+                        )
+                        .min(2)
+                        .max(50),
+                    title: z.string().describe('Event title in 2-4 words').min(5).max(80),
+                    description: z
+                        .string()
+                        .describe('Brief description of the event or milestone')
+                        .min(20)
+                        .max(150),
+                }),
+            )
+            .length(5)
+            .describe('Timeline must contain exactly 5 chronological events'),
+    }),
+    version: z.literal(1),
+}) satisfies z.ZodType<ITimelineSlideDataStructure>;
+export type TimelineSlideData = z.infer<typeof TimelineSlideDataSchema>;
+
 export const SlideContentSchema = z.discriminatedUnion('contentType', [
     CoverSlideDataSchema,
     StructuredListSlideDataSchema,
@@ -317,5 +361,6 @@ export const SlideContentSchema = z.discriminatedUnion('contentType', [
     ThankYouSlideDataSchema,
     TableSlideDataSchema,
     ChartSlideDataSchema,
+    TimelineSlideDataSchema,
 ]);
 export type SlideContent = z.infer<typeof SlideContentSchema>;