@purpleschool/gptbot 0.11.5 → 0.11.7

package/commands/tools/spell-corrector/delete-spell-corrector-job-by-uuid.command.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export namespace DeleteSpellCorrectorJobByUUIDCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.void();
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/spell-corrector/find-spell-corrector-job-by-uuid.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { SpellCorrectorToolJobSchema } from '../../../models';
+
+export namespace FindSpellCorrectorJobByUUIDCommand {
+    export const RequestParamsSchema = SpellCorrectorToolJobSchema.pick({
+        uuid: true,
+    });
+
+    export type Request = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SpellCorrectorToolJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/spell-corrector/find-spell-corrector-jobs.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { SpellCorrectorToolJobSchema } from '../../../models';
+
+export namespace FindSpellCorrectorJobsCommand {
+    export const RequestQuerySchema = z.object({
+        limit: z.coerce.number().min(1).optional(),
+        offset: z.coerce.number().min(0).default(0).optional(),
+        title: z.string().optional(),
+    });
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.array(SpellCorrectorToolJobSchema),
+        totalPages: z.number(),
+        page: z.number(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/spell-corrector/get-spell-corrector-tool-config.command.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { SpellCorrectorToolConfigSchema } from '../../../models';
+
+export namespace GetSpellCorrectorToolConfigCommand {
+    export const ResponseSchema = z.object({
+        data: SpellCorrectorToolConfigSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/spell-corrector/index.ts

@@ -0,0 +1,9 @@
+export * from './spell-corrector.command';
+export * from './delete-spell-corrector-job-by-uuid.command';
+export * from './delete-all-spell-corrector-jobs.command';
+export * from './set-reaction-to-spell-corrector-job.command';
+export * from './update-spell-corrector-job-title.command';
+export * from './retry-spell-corrector-job.command';
+export * from './find-spell-corrector-job-by-uuid.command';
+export * from './find-spell-corrector-jobs.command';
+export * from './get-spell-corrector-tool-config.command';

package/commands/tools/spell-corrector/retry-spell-corrector-job.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SpellCorrectorToolJobSchema } from '../../../models';
+
+export namespace RetrySpellCorrectorJobCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SpellCorrectorToolJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/spell-corrector/set-reaction-to-spell-corrector-job.command.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { SpellCorrectorToolJobSchema } from '../../../models';
+import { USER_REACTION } from '../../../constants';
+
+export namespace SetReactionToSpellCorrectorJobCommand {
+    export const RequestSchema = z
+        .object({
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not DISLIKED',
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SpellCorrectorToolJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/spell-corrector/spell-corrector.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ToolJobSchema } from '../../../models';
+
+export namespace SpellCorrectorCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        prompt: z.string().min(1).max(100000),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ToolJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/spell-corrector/update-spell-corrector-job-title.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { SpellCorrectorToolJobSchema } from '../../../models';
+
+export namespace UpdateSpellCorrectorJobTitleCommand {
+    export const RequestSchema = z.object({
+        title: z.string().min(1).max(40).trim(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SpellCorrectorToolJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/video-editor/edit-video.command.ts

@@ -6,6 +6,8 @@ export namespace EditVideoCommand {
         modelId: z.string().uuid(),
         prompt: z.string(),
         fileId: z.string().uuid(),
+        resolution: z.string().optional(),
+        duration: z.number().optional(),
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/tools/video-editor/retry-video-editor-job.command.ts

@@ -12,6 +12,8 @@ export namespace RetryVideoEditorJobCommand {
         modelId: z.string().uuid().optional(),
         prompt: z.string().optional(),
         fileId: z.string().uuid().optional(),
+        resolution: z.string().optional(),
+        duration: z.number().optional(),
     });
     export type RequestBody = z.infer<typeof RequestBodySchema>;
 

package/commands/unregistered-user/index.ts

@@ -1 +1,2 @@
 export * from './create-unregistered-user.command';
+export * from './patch-locale.command';

package/commands/unregistered-user/patch-locale.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { LOCALE } from '../../constants';
+
+export namespace PatchUnregisteredUserLocaleCommand {
+    export const RequestSchema = z.object({
+        locale: z.nativeEnum(LOCALE),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            locale: z.nativeEnum(LOCALE),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/user/get-me.command.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ROLE, SIGNUP_METHOD, USER_STATUS } from '../../constants';
+import { LOCALE, ROLE, SIGNUP_METHOD, USER_STATUS } from '../../constants';
 import { UserProfileResponseSchema } from '../../models';
 
 export namespace GetMeCommand {
@@ -17,6 +17,7 @@ export namespace GetMeCommand {
             telegramId: z.number().nullable(),
             telegramUserName: z.string().nullable(),
             webmasterId: z.string().uuid().nullable(),
+            locale: z.nativeEnum(LOCALE),
             profile: UserProfileResponseSchema,
         }),
     });

package/commands/user/index.ts

@@ -1,6 +1,7 @@
 export * from './check-email.command';
 export * from './find-user-by-uuid.command';
 export * from './get-me.command';
+export * from './patch-locale.command';
 export * from './up-token-bonus-balance.command';
 export * from './find-users-by-criteria.command';
 export * from './get-user-balance.command';

package/commands/user/patch-locale.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { LOCALE } from '../../constants';
+
+export namespace PatchUserLocaleCommand {
+    export const RequestSchema = z.object({
+        locale: z.nativeEnum(LOCALE),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            locale: z.nativeEnum(LOCALE),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/ai-model/enums/ai-model-strategy.enum.ts

@@ -10,6 +10,7 @@ export enum AI_MODEL_STRATEGY {
     STABLE_DIFFUSION_IMAGE_GENERATION = 'stable_diffusion_image_generation',
     LLAMA_TEXT_GENERATION = 'llama_text_generation',
     QWEN_TEXT_GENERATION = 'qwen_text_generation',
+    KIE_OPENAI_TEXT_GENERATION = 'kie_openai_text_generation',
     GROK_IMAGE_GENERATION = 'grok_image_generation',
     GEMINI_TEXT_GENERATION = 'gemini_text_generation',
     GEMINI_IMAGE_GENERATION = 'gemini_image_generation',

package/constants/model/enums/unified-model-content-type.enum.ts

@@ -15,4 +15,6 @@ export enum UNIFIED_MODEL_CONTENT_TYPE {
     IMAGE_GENERATION = 'IMAGE_GENERATION',
     INTERIOR_DESIGN = 'INTERIOR_DESIGN',
     MARKETPLACE_CARD = 'MARKETPLACE_CARD',
+    SOLVING_EDU_TASK = 'SOLVING_EDU_TASK',
+    SPELL_CORRECTOR = 'SPELL_CORRECTOR',
 }

package/constants/presentation/enums/index.ts

@@ -7,3 +7,4 @@ export * from './slide-image-slot-action.enum';
 export * from './presentation-ai-action-type.enum';
 export * from './presentation-ai-action-pricing-type.enum';
 export * from './presentation-ai-action-call-status.enum';
+export * from './presentation-target-audience.enum';

package/constants/presentation/enums/presentation-target-audience.enum.ts

@@ -0,0 +1,6 @@
+export enum PRESENTATION_TARGET_AUDIENCE {
+    NONE = 'NONE',
+    SCHOOL = 'SCHOOL',
+    UNIVERSITY = 'UNIVERSITY',
+    BUSINESS = 'BUSINESS',
+}

package/constants/subscription/enums/subscription-feature-type.enum.ts

@@ -25,6 +25,12 @@ export enum SUBSCRIPTION_FEATURE_TYPE {
     IMAGE_EDITOR_MODEL_ACCESS = 'image_editor_model_access',
     INTERIOR_DESIGN_QUOTA = 'interior_design_quota',
     INTERIOR_DESIGN_MODEL_ACCESS = 'interior_design_model_access',
+    SPELL_CORRECTOR_QUOTA = 'spell_corrector_quota',
+    SPELL_CORRECTOR_MODEL_ACCESS = 'spell_corrector_model_access',
+    PARAPHRASE_TYPE_ACCESS = 'paraphrase_type_access',
+    MARKETPLACE_CARD_MODEL_ACCESS = 'marketplace_card_model_access',
+    EDU_TASK_MODEL_ACCESS = 'edu_task_model_access',
+    VIDEO_EDITOR_MODEL_ACCESS = 'video_editor_model_access',
 }
 
 export enum SUBSCRIPTION_FEATURE_KIND {
@@ -33,7 +39,6 @@ export enum SUBSCRIPTION_FEATURE_KIND {
     IMAGE_GENERATION = 'image_generation',
     TTS = 'tts',
     STT = 'stt',
-    PRESENTATIONS = 'presentations',
     VIDEO = 'video',
     PRESENTATION = 'presentation',
     BASE = 'base',
@@ -41,4 +46,9 @@ export enum SUBSCRIPTION_FEATURE_KIND {
     WRITER = 'writer',
     IMAGE_EDITOR = 'image_editor',
     INTERIOR_DESIGN = 'interior_design',
+    SPELL_CORRECTOR = 'spell_corrector',
+    PARAPHRASE = 'paraphrase',
+    MARKETPLACE_CARD = 'marketplace_card',
+    EDU_TASK = 'edu_task',
+    VIDEO_EDITOR = 'video_editor',
 }

package/constants/tool-video-editor/enums/index.ts

@@ -1 +1,2 @@
 export * from './video-editor-model-strategy.enum';
+export * from './video-editor-pricing-rule-type.enum';

package/constants/tool-video-editor/enums/video-editor-pricing-rule-type.enum.ts

@@ -0,0 +1,4 @@
+export enum VIDEO_EDITOR_PRICING_RULE_TYPE {
+    FLAT = 'flat',
+    PER_SECOND = 'per_second',
+}

package/constants/user/enums/index.ts

@@ -2,3 +2,4 @@ export * from './singup-method.enum';
 export * from './user-status';
 export * from './user-sort-by.enum';
 export * from './sort-order.enum';
+export * from './locale.enum';

package/constants/user/enums/locale.enum.ts

@@ -0,0 +1,4 @@
+export enum LOCALE {
+    RU = 'ru',
+    EN = 'en',
+}

package/helpers/video-editor/calculate-video-editing-price.helper.ts

@@ -1,3 +1,53 @@
-export function calculateVideoEditingPrice({ pricePerCall }: { pricePerCall: number }) {
-    return pricePerCall;
+import { VIDEO_EDITOR_PRICING_RULE_TYPE } from '../../constants';
+import {
+    VideoEditorModelPricingRuleCondition,
+    VideoEditorModelPricingRules,
+    VideoEditorPricingRequestParams,
+} from '../../models';
+
+function matchesCondition(
+    condition: VideoEditorModelPricingRuleCondition,
+    params: VideoEditorPricingRequestParams,
+): boolean {
+    const keys = Object.keys(condition) as (keyof VideoEditorModelPricingRuleCondition)[];
+
+    return keys.every((key) => {
+        const expected = condition[key];
+        if (expected === undefined || expected === null || expected === '') {
+            return true;
+        }
+
+        const value = params[key];
+        if (value === undefined || value === null) {
+            return false;
+        }
+
+        return value === expected;
+    });
+}
+
+export function calculateVideoEditingPrice({
+    pricePerCall,
+    params,
+    rules,
+}: {
+    pricePerCall: number;
+    params: VideoEditorPricingRequestParams;
+    rules: VideoEditorModelPricingRules;
+}): number {
+    const perSecondRule = rules
+        .filter((r) => r.type === VIDEO_EDITOR_PRICING_RULE_TYPE.PER_SECOND)
+        .find((r) => matchesCondition(r.condition, params));
+
+    const base = perSecondRule ? perSecondRule.value * params.duration : pricePerCall;
+
+    const flatMarkup = rules.reduce((sum, r) => {
+        if (r.type !== VIDEO_EDITOR_PRICING_RULE_TYPE.FLAT) {
+            return sum;
+        }
+
+        return matchesCondition(r.condition, params) ? sum + r.value : sum;
+    }, 0);
+
+    return Math.ceil(base + flatMarkup);
 }

package/models/subscription-feature.schema.ts

@@ -214,6 +214,57 @@ export type InteriorDesignModelAccessFeature = z.infer<
     typeof InteriorDesignModelAccessFeatureSchema
 >;
 
+export const SpellCorrectorQuotaFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.SPELL_CORRECTOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.SPELL_CORRECTOR_QUOTA),
+    value: z.number(),
+});
+export type SpellCorrectorQuotaFeature = z.infer<typeof SpellCorrectorQuotaFeatureSchema>;
+
+export const SpellCorrectorModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.SPELL_CORRECTOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.SPELL_CORRECTOR_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type SpellCorrectorModelAccessFeature = z.infer<
+    typeof SpellCorrectorModelAccessFeatureSchema
+>;
+
+export const ParaphraseTypeAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.PARAPHRASE),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.PARAPHRASE_TYPE_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type ParaphraseTypeAccessFeature = z.infer<typeof ParaphraseTypeAccessFeatureSchema>;
+
+export const MarketplaceCardModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.MARKETPLACE_CARD),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.MARKETPLACE_CARD_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type MarketplaceCardModelAccessFeature = z.infer<
+    typeof MarketplaceCardModelAccessFeatureSchema
+>;
+
+export const EduTaskModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.EDU_TASK),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.EDU_TASK_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type EduTaskModelAccessFeature = z.infer<typeof EduTaskModelAccessFeatureSchema>;
+
+export const VideoEditorModelAccessFeatureSchema = SubscriptionFeatureBaseSchema.extend({
+    kind: z.literal(SUBSCRIPTION_FEATURE_KIND.VIDEO_EDITOR),
+    type: z.literal(SUBSCRIPTION_FEATURE_TYPE.VIDEO_EDITOR_MODEL_ACCESS),
+    isAvailable: z.boolean(),
+    modelId: z.string(),
+});
+export type VideoEditorModelAccessFeature = z.infer<typeof VideoEditorModelAccessFeatureSchema>;
+
 export const SubscriptionFeatureSchema = z.union([
     AiModelAccessFeatureSchema,
     RequestsQuotaFeatureSchema,
@@ -240,6 +291,12 @@ export const SubscriptionFeatureSchema = z.union([
     InteriorDesignQuotaFeatureSchema,
     InteriorDesignModelAccessFeatureSchema,
     ImageGenerationAccessFeatureSchema,
+    SpellCorrectorQuotaFeatureSchema,
+    SpellCorrectorModelAccessFeatureSchema,
+    ParaphraseTypeAccessFeatureSchema,
+    MarketplaceCardModelAccessFeatureSchema,
+    EduTaskModelAccessFeatureSchema,
+    VideoEditorModelAccessFeatureSchema,
 ]);
 
 export type SubscriptionFeature = z.infer<typeof SubscriptionFeatureSchema>;

package/models/subscription.schema.ts

@@ -58,3 +58,14 @@ export const SubscriptionWithSubTypesSchema = z.intersection(
 export const SubscriptionWithFeaturesSchema = SubscriptionSchema.extend({
     features: z.array(SubscriptionFeatureSchema),
 });
+
+export const SubscriptionWithoutFeaturesSchema = SubscriptionSchema.omit({
+    features: true,
+});
+
+export const SubscriptionWithSubTypesWithoutFeaturesSchema = z.intersection(
+    SubscriptionWithoutFeaturesSchema,
+    z.object({
+        subTypes: z.array(SubscriptionWithoutFeaturesSchema),
+    }),
+);

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

@@ -40,6 +40,8 @@ export const ImageEditorModelSchema = z.object({
     uuid: z.string(),
     title: z.string(),
     description: z.string(),
+    isNew: z.boolean(),
+    tierLabel: z.string(),
     pricePerImage: z.number(),
     order: z.number(),
     icons: IconVariantsSchema,

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

@@ -43,6 +43,7 @@ export const ImageGenerationModelSchema = z.object({
     order: z.number(),
     status: z.string(),
     price: z.number(),
+    isNew: z.boolean(),
     params: ImageGenerationModelParamsSchema,
     supportsImageAttachment: z.boolean(),
     maxAttachedImages: z.number(),

package/models/tools/index.ts

@@ -13,3 +13,4 @@ export * from './image-generation';
 export * from './marketplace-card';
 export * from './interior-design';
 export * from './solving-edu-task';
+export * from './spell-corrector';

package/models/tools/presentation/index.ts

@@ -6,3 +6,4 @@ export * from './slide.schema';
 export * from './slide-content.schema';
 export * from './presentation-config.schema';
 export * from './presentation-ai-action.schema';
+export * from './presentation-title-page.schema';

package/models/tools/presentation/presentation-template.schema.ts

@@ -6,6 +6,7 @@ export const PresentationTemplateSchema = z.object({
     image: z.string(),
     order: z.number(),
     imagePlaceholder: z.string(),
+    price: z.number(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/models/tools/presentation/presentation-title-page.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const PresentationTitlePageSchema = z.object({
+    author: z.string().optional().nullable(),
+    createdAt: z.coerce.date().optional().nullable(),
+    email: z.string().email().optional().nullable(),
+});
+
+export type PresentationTitlePage = z.infer<typeof PresentationTitlePageSchema>;

package/models/tools/presentation/presentation.schema.ts

@@ -1,7 +1,12 @@
 import { z } from 'zod';
-import { PRESENTATION_STAGE, USER_REACTION } from '../../../constants';
+import {
+    PRESENTATION_STAGE,
+    PRESENTATION_TARGET_AUDIENCE,
+    USER_REACTION,
+} from '../../../constants';
 import { SlideOutlineSchema } from './slide-outline.schema';
 import { SlideSchema } from './slide.schema';
+import { PresentationTitlePageSchema } from './presentation-title-page.schema';
 
 export const PresentationSchema = z.object({
     uuid: z.string().uuid(),
@@ -17,6 +22,8 @@ export const PresentationSchema = z.object({
     slideCount: z.number(),
     lastContentUpdateAt: z.date().nullable(),
     lastPptxExportedAt: z.date().nullable(),
+    titlePage: PresentationTitlePageSchema.nullable(),
+    targetAudience: z.nativeEnum(PRESENTATION_TARGET_AUDIENCE),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

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

@@ -19,18 +19,24 @@ import { SLIDE_CONTENT_TYPE } from '../../../constants';
 export const CoverSlideDataUserEditSchema = z.object({
     contentType: z.literal(SLIDE_CONTENT_TYPE.COVER),
     title: z.string().max(1000),
-    author: z.object({
-        label: z.string().max(200),
-        value: z.string().max(500),
-    }),
-    date: z.object({
-        label: z.string().max(200),
-        value: z.string().max(500),
-    }),
-    email: z.object({
-        label: z.string().max(200),
-        value: z.string().max(500),
-    }),
+    author: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
+    date: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
+    email: z
+        .object({
+            label: z.string().min(1).max(100),
+            value: z.string().min(1).max(200),
+        })
+        .optional(),
     version: z.literal(1),
 }) satisfies z.ZodType<ICoverSlideDataStructure>;
 

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

@@ -26,9 +26,9 @@ export type IconSlot = z.infer<typeof IconSlotSchema>;
 export interface ICoverSlideDataStructure {
     contentType: SLIDE_CONTENT_TYPE.COVER;
     title: string;
-    author: { label: string; value: string };
-    date: { label: string; value: string };
-    email: { label: string; value: string };
+    author?: { label: string; value: string };
+    date?: { label: string; value: string };
+    email?: { label: string; value: string };
     version: 1;
 }
 
@@ -125,24 +125,28 @@ export interface ITimelineSlideDataStructure {
 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),
-    author: z.object({
-        label: z.string().describe('Literal "Author" in presentation\'s language'),
-        value: z
-            .string()
-            .describe('Literal "Author of the presentation" in presentation\'s language'),
-    }),
-    date: z.object({
-        label: z.string().describe('Literal "Date" in presentation\'s language'),
-        value: z
-            .string()
-            .describe(
-                'Date of the presentation in the "dd month yyyy" format in presentation\'s locale',
-            ),
-    }),
-    email: z.object({
-        label: z.string().describe('Just default word "Email"'),
-        value: z.string().describe('Just default "email@example.com"'),
-    }),
+    author: z
+        .object({
+            label: z.string().describe('Literal "Author" in presentation\'s language'),
+            value: z.string().describe('Author value from titlePage if provided'),
+        })
+        .optional(),
+    date: z
+        .object({
+            label: z.string().describe('Literal "Date" in presentation\'s language'),
+            value: z
+                .string()
+                .describe(
+                    'Date from titlePage in the "dd month yyyy" format in presentation\'s locale',
+                ),
+        })
+        .optional(),
+    email: z
+        .object({
+            label: z.string().describe('Localized contact/email label'),
+            value: z.string().describe('Email value from titlePage if provided'),
+        })
+        .optional(),
     version: z.literal(1),
 }) satisfies z.ZodType<ICoverSlideDataStructure>;
 export type CoverSlideData = z.infer<typeof CoverSlideDataSchema>;