@purpleschool/student-works 1.2.2 → 1.3.1

package/commands/presentation/generate-and-insert-slide.command.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { SlideSchema } from '../../models/presentation';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../../constants';
+
+export namespace GenerateAndInsertSlideCommand {
+    export const RequestSchema = z.object({
+        contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+        prompt: z.string().max(10000).optional(),
+        title: z.string().min(1).max(80),
+        position: z.number().min(0),
+        layoutId: z.nativeEnum(SLIDE_LAYOUT).optional(),
+    });
+
+    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: z.array(SlideSchema),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/generate-presentation-slides.command.ts

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

package/commands/presentation/get-presentation-config.command.ts

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

package/commands/presentation/index.ts

@@ -0,0 +1,23 @@
+export * from './build-blank-slide.command';
+export * from './create-presentation.command';
+export * from './delete-all-user-presentations.command';
+export * from './delete-slide-outline.command';
+export * from './delete-presentation.command';
+export * from './export-presentation-as-pptx.command';
+export * from './find-presentation-by-uuid.command';
+export * from './find-presentation-outline.command';
+export * from './find-presentations.command';
+export * from './generate-presentation-slides.command';
+export * from './generate-and-insert-slide.command';
+export * from './get-presentation-config.command';
+export * from './reposition-slide-outline.command';
+export * from './update-slide-outline.command';
+export * from './update-presentation-outline.command';
+export * from './update-presentation.command';
+export * from './update-presentation-slides.command';
+export * from './update-slide-image-slot.command';
+export * from './update-slide-outline.command';
+export * from './presentation-paraphrase.command';
+export * from './presentation-generate-report.command';
+export * from './update-slide.command';
+export * from './set-reaction-to-presentation.command';

package/commands/presentation/presentation-generate-report.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+
+export namespace PresentationGenerateReportCommand {
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string(),
+    });
+
+    export const RequestSchema = RequestParamsSchema;
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            output: z.string(),
+            docxUrl: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/presentation-paraphrase.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+
+export namespace PresentationParaphraseCommand {
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string(),
+        slideId: z.string(),
+    });
+
+    export const RequestBodySchema = z.object({
+        selectionText: z.string().max(10000),
+    });
+
+    export const RequestSchema = RequestParamsSchema.merge(RequestBodySchema);
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            output: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/reposition-slide-outline.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+
+export namespace RepositionSlideOutlineCommand {
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string().uuid(),
+        slideOutlineId: z.string().uuid(),
+    });
+    export type Params = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        newPosition: z.number().min(0),
+    });
+    export type Request = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.void();
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/set-reaction-to-presentation.command.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../constants';
+import { PresentationSchema } from '../../models/presentation';
+
+export namespace SetReactionToPresentationCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestBodySchema = 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 RequestParams = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: PresentationSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/update-presentation-outline.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { SlideOutlineBulkUpdateSchema, SlideOutlineSchema } from '../../models/presentation';
+
+export namespace UpdatePresentationOutlineCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+
+    export const RequestBodySchema = SlideOutlineBulkUpdateSchema;
+
+    export type Request = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: SlideOutlineSchema.array(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/update-presentation-slides.command.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { SlideBulkUpdateSchema } from '../../models/presentation';
+
+export namespace UpdatePresentationSlidesCommand {
+    export const RequestSchema = z.object({
+        data: SlideBulkUpdateSchema,
+    });
+
+    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: z.array(
+            z.object({
+                uuid: z.string().uuid(),
+                order: z.number(),
+                contentTypeId: z.string(),
+                layoutId: z.string(),
+                content: z.record(z.any()),
+                createdAt: z.date(),
+                updatedAt: z.date(),
+            }),
+        ),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/update-presentation.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { PresentationSchema } from '../../models/presentation';
+
+export namespace UpdatePresentationCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = PresentationSchema.pick({
+        title: true,
+        templateId: true,
+    }).partial();
+    export type Request = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: PresentationSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/update-slide-image-slot.command.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { SLIDE_IMAGE_SLOT_ACTION } from '../../constants';
+import { SlideImageSlotSchema } from '../../models/presentation/slide-image-slot.schema';
+
+export namespace UpdateSlideImageSlotCommand {
+    const ReplacePayload = z.object({
+        action: z.literal(SLIDE_IMAGE_SLOT_ACTION.REPLACE),
+        fileId: z.string().uuid(),
+    });
+
+    const GeneratePayload = z.object({
+        action: z.literal(SLIDE_IMAGE_SLOT_ACTION.GENERATE),
+        prompt: z.string().min(1).max(1000).optional(),
+    });
+
+    const UpdateImageSlotPayloadSchema = z.discriminatedUnion('action', [
+        ReplacePayload,
+        GeneratePayload,
+    ]);
+    export type UpdateImageSlotPayload = z.infer<typeof UpdateImageSlotPayloadSchema>;
+
+    export const RequestSchema = z.object({
+        payload: UpdateImageSlotPayloadSchema,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string().uuid(),
+        slideId: z.string().uuid(),
+        slotId: z.string().uuid().optional(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            imageSlot: SlideImageSlotSchema,
+        }),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/update-slide-outline.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { SlideOutlineSchema } from '../../models/presentation';
+import { SLIDE_CONTENT_TYPE } from '../../constants';
+
+export namespace UpdateSlideOutlineCommand {
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string().uuid(),
+        slideOutlineId: z.string().uuid(),
+    });
+
+    export const RequestBodySchema = z
+        .object({
+            title: z.string(),
+            body: z.string(),
+            contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+        })
+        .partial();
+
+    export type Request = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: SlideOutlineSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/presentation/update-slide.command.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { SlideSchema, SlideUpdateSchema } from '../../models/presentation';
+
+export namespace UpdateSlideCommand {
+    export const RequestParamsSchema = z.object({
+        presentationId: z.string(),
+        slideId: z.string(),
+    });
+
+    export const RequestBodySchema = z.object({
+        data: SlideUpdateSchema,
+    });
+
+    export const RequestSchema = RequestParamsSchema.merge(RequestBodySchema);
+
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: SlideSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constants/errors/errors.ts

@@ -1192,4 +1192,240 @@ export const ERRORS = {
         code: 'TOOLS_001',
         httpCode: 500,
     },
+    // PRESENTATION
+    PRESENTATION_SAVE_ERROR: {
+        message: 'Ошибка при сохранении презентации',
+        code: 'PRESENTATION_001',
+        httpCode: 500,
+    },
+    PRESENTATION_NOT_FOUND: {
+        message: 'Презентация не найдена',
+        code: 'PRESENTATION_002',
+        httpCode: 404,
+    },
+    PRESENTATION_OWNERSHIP_ERROR: {
+        message: 'Пользователь не является владельцем презентации',
+        code: 'PRESENTATION_003',
+        httpCode: 403,
+    },
+    PRESENTATION_STAGE_OUTLINE_GENERATED_REQUIRED: {
+        message: 'Требуется стадия генерации плана презентации',
+        code: 'PRESENTATION_004',
+        httpCode: 400,
+    },
+    PRESENTATION_TOO_MANY_SLIDES: {
+        message: 'Слишком много слайдов в презентации',
+        code: 'PRESENTATION_005',
+        httpCode: 400,
+    },
+    PRESENTATION_TOO_FEW_SLIDES: {
+        message: 'Слишком мало слайдов в презентации',
+        code: 'PRESENTATION_006',
+        httpCode: 400,
+    },
+    PRESENTATION_CREATE_BLANK_SLIDE_ERROR: {
+        message: 'Ошибка при создании пустого слайда',
+        code: 'PRESENTATION_007',
+        httpCode: 500,
+    },
+    PRESENTATION_SLIDE_NOT_FOUND: {
+        message: 'Слайд не найден',
+        code: 'PRESENTATION_008',
+        httpCode: 404,
+    },
+    PRESENTATION_INVALID_CONTENT_TYPE_CHANGE: {
+        message: 'Недопустимое изменение типа содержимого',
+        code: 'PRESENTATION_009',
+        httpCode: 400,
+    },
+    PRESENTATION_SLIDE_IMAGE_SLOT_NOT_FOUND: {
+        message: 'Слот изображения слайда не найден',
+        code: 'PRESENTATION_010',
+        httpCode: 404,
+    },
+    PRESENTATION_SLIDE_IMAGE_UPDATE_ERROR: {
+        message: 'Ошибка при обновлении изображения слайда',
+        code: 'PRESENTATION_011',
+        httpCode: 500,
+    },
+    PRESENTATION_IMAGE_GENERATION_ERROR: {
+        message: 'Ошибка при генерации изображения',
+        code: 'PRESENTATION_012',
+        httpCode: 500,
+    },
+    PRESENTATION_INVALID_SLIDE_POSITION: {
+        message: 'Недопустимая позиция слайда',
+        code: 'PRESENTATION_013',
+        httpCode: 400,
+    },
+    PRESENTATION_OUTLINE_UPDATE_ERROR: {
+        message: 'Ошибка при обновлении плана презентации',
+        code: 'PRESENTATION_014',
+        httpCode: 500,
+    },
+    PRESENTATION_SAVE_SLIDES_ERROR: {
+        message: 'Ошибка при сохранении слайдов',
+        code: 'PRESENTATION_015',
+        httpCode: 500,
+    },
+    PRESENTATION_GENERATE_OUTLINE_ERROR: {
+        message: 'Ошибка при генерации плана презентации',
+        code: 'PRESENTATION_016',
+        httpCode: 500,
+    },
+    PRESENTATION_FIND_ERROR: {
+        message: 'Ошибка при поиске презентации',
+        code: 'PRESENTATION_017',
+        httpCode: 500,
+    },
+    PRESENTATION_GENERATE_SLIDES_ERROR: {
+        message: 'Ошибка при генерации слайдов',
+        code: 'PRESENTATION_018',
+        httpCode: 500,
+    },
+    PRESENTATION_DELETE_ERROR: {
+        message: 'Ошибка при удалении презентации',
+        code: 'PRESENTATION_019',
+        httpCode: 500,
+    },
+    PRESENTATION_STAGE_CREATED_REQUIRED: {
+        message: 'Требуется стадия создания презентации',
+        code: 'PRESENTATION_020',
+        httpCode: 400,
+    },
+    PRESENTATION_STAGE_SLIDES_GENERATED_REQUIRED: {
+        message: 'Требуется стадия генерации слайдов',
+        code: 'PRESENTATION_021',
+        httpCode: 400,
+    },
+    // SLIDE_OUTLINE
+    SLIDE_OUTLINE_INVALID_POSITION: {
+        message: 'Недопустимая позиция слайда в плане',
+        code: 'SLIDE_OUTLINE_001',
+        httpCode: 400,
+    },
+    SLIDE_OUTLINE_NOT_FOUND: {
+        message: 'Слайд в плане не найден',
+        code: 'SLIDE_OUTLINE_002',
+        httpCode: 404,
+    },
+    SLIDE_OUTLINE_FIND_ERROR: {
+        message: 'Ошибка при поиске слайдов в плане',
+        code: 'SLIDE_OUTLINE_003',
+        httpCode: 500,
+    },
+    SLIDE_OUTLINE_UPDATE_ERROR: {
+        message: 'Ошибка при обновлении слайда в плане',
+        code: 'SLIDE_OUTLINE_004',
+        httpCode: 500,
+    },
+    SLIDE_OUTLINE_REPOSITION_ERROR: {
+        message: 'Ошибка при изменении позиции слайда в плане',
+        code: 'SLIDE_OUTLINE_005',
+        httpCode: 500,
+    },
+    SLIDE_OUTLINE_DELETE_ERROR: {
+        message: 'Ошибка при удалении слайда из плана',
+        code: 'SLIDE_OUTLINE_006',
+        httpCode: 500,
+    },
+    SLIDE_OUTLINE_SAVE_ERROR: {
+        message: 'Ошибка при сохранении слайдов в плане',
+        code: 'SLIDE_OUTLINE_007',
+        httpCode: 500,
+    },
+    // PPTX_GENERATION
+    PPTX_GENERATION_INTERNAL_ERROR: {
+        message: 'Ошибка при генерации PPTX файла',
+        code: 'PPTX_GENERATION_001',
+        httpCode: 500,
+    },
+    // PRESENTATION_AI_ACTION
+    PRESENTATION_AI_ACTION_PROMPT_TOO_LONG: {
+        message: 'Промпт для действия AI слишком длинный',
+        code: 'PRESENTATION_AI_ACTION_001',
+        httpCode: 400,
+    },
+    PRESENTATION_AI_ACTION_NOT_FOUND: {
+        message: 'Действие AI не найдено',
+        code: 'PRESENTATION_AI_ACTION_002',
+        httpCode: 404,
+    },
+    PRESENTATION_AI_ACTION_FIND_ERROR: {
+        message: 'Ошибка при поиске действия AI',
+        code: 'PRESENTATION_AI_ACTION_003',
+        httpCode: 500,
+    },
+    // AI
+    AI_ERROR: {
+        message: 'Ошибка при работе с AI',
+        code: 'AI_001',
+        httpCode: 500,
+    },
+    // SLIDE_LAYOUT
+    SLIDE_LAYOUT_FIND_ERROR: {
+        message: 'Ошибка при поиске макета слайда',
+        code: 'SLIDE_LAYOUT_001',
+        httpCode: 500,
+    },
+    SLIDE_LAYOUT_NOT_FOUND: {
+        message: 'Макет слайда не найден',
+        code: 'SLIDE_LAYOUT_002',
+        httpCode: 404,
+    },
+    SLIDE_LAYOUT_SAVE_ERROR: {
+        message: 'Ошибка при сохранении макета слайда',
+        code: 'SLIDE_LAYOUT_003',
+        httpCode: 500,
+    },
+    // SLIDE_IMAGE_SLOT
+    SLIDE_IMAGE_SLOT_SAVE_ERROR: {
+        message: 'Ошибка при сохранении слота изображения слайда',
+        code: 'SLIDE_IMAGE_SLOT_001',
+        httpCode: 500,
+    },
+    // SLIDE_CONTENT_TYPE
+    SLIDE_CONTENT_TYPE_FIND_ERROR: {
+        message: 'Ошибка при поиске типа содержимого слайда',
+        code: 'SLIDE_CONTENT_TYPE_001',
+        httpCode: 500,
+    },
+    // PRESENTATION_TEMPLATE
+    PRESENTATION_TEMPLATE_NOT_FOUND: {
+        message: 'Шаблон презентации не найден',
+        code: 'PRESENTATION_TEMPLATE_001',
+        httpCode: 404,
+    },
+    PRESENTATION_TEMPLATE_FIND_ERROR: {
+        message: 'Ошибка при поиске шаблона презентации',
+        code: 'PRESENTATION_TEMPLATE_002',
+        httpCode: 500,
+    },
+    // PRESENTATION_AI_ACTION_CALL
+    PRESENTATION_AI_ACTION_CALL_NOT_FOUND: {
+        message: 'Вызов действия AI не найден',
+        code: 'PRESENTATION_AI_ACTION_CALL_001',
+        httpCode: 404,
+    },
+    PRESENTATION_AI_ACTION_CALL_FIND_ERROR: {
+        message: 'Ошибка при поиске вызова действия AI',
+        code: 'PRESENTATION_AI_ACTION_CALL_002',
+        httpCode: 500,
+    },
+    PRESENTATION_AI_ACTION_CALL_SAVE_ERROR: {
+        message: 'Ошибка при сохранении вызова действия AI',
+        code: 'PRESENTATION_AI_ACTION_CALL_003',
+        httpCode: 500,
+    },
+    // LANGUAGE
+    LANGUAGE_NOT_FOUND: {
+        message: 'Язык не найден',
+        code: 'LANGUAGE_001',
+        httpCode: 404,
+    },
+    LANGUAGE_FIND_ERROR: {
+        message: 'Ошибка при поиске языка',
+        code: 'LANGUAGE_002',
+        httpCode: 500,
+    },
 };

package/constants/index.ts

@@ -14,3 +14,4 @@ export * from './page';
 export * from './writer';
 export * from './files';
 export * from './common';
+export * from './presentation';

package/constants/presentation/enums/index.ts

@@ -0,0 +1,10 @@
+export * from './presentation-stage.enum';
+export * from './slide-content-type.enum';
+export * from './slide-icon-slot-status.enum';
+export * from './slide-image-slot.status.enum';
+export * from './slide-layout.enum';
+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 './slide-icon-slot-status.enum';

package/constants/presentation/enums/presentation-ai-action-call-status.enum.ts

@@ -0,0 +1,5 @@
+export enum PRESENTATION_AI_ACTION_CALL_STATUS {
+    PROCESSING = 'processing',
+    COMPLETED = 'completed',
+    FAILED = 'failed',
+}

package/constants/presentation/enums/presentation-ai-action-pricing-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_PRICING_TYPE {
+    PER_CHARACTER = 'PER_CHARACTER',
+    FLAT = 'FLAT',
+}

package/constants/presentation/enums/presentation-ai-action-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PRESENTATION_AI_ACTION_TYPE {
+    PARAPHRASE = 'PARAPHRASE',
+    GENERATE_REPORT = 'GENERATE_REPORT',
+}

package/constants/presentation/enums/presentation-stage.enum.ts

@@ -0,0 +1,13 @@
+export enum PRESENTATION_STAGE {
+    CREATED = 'CREATED',
+
+    GENERATING_OUTLINE = 'GENERATING_OUTLINE',
+    OUTLINE_GENERATED = 'OUTLINE_GENERATED',
+    OUTLINE_GENERATION_FAILED = 'OUTLINE_GENERATION_FAILED',
+
+    GENERATING_SLIDES = 'GENERATING_SLIDES',
+    SLIDES_GENERATED = 'SLIDES_GENERATED',
+    SLIDES_GENERATION_FAILED = 'SLIDES_GENERATION_FAILED',
+
+    DELETED = 'DELETED',
+}

package/constants/presentation/enums/slide-content-type.enum.ts

@@ -0,0 +1,12 @@
+export enum SLIDE_CONTENT_TYPE {
+    COVER = 'COVER',
+    TEXT = 'TEXT',
+    TEXT_WITH_IMAGE = 'TEXT_WITH_IMAGE',
+    SECTION_BREAK = 'SECTION_BREAK',
+    STRUCTURED_LIST = 'STRUCTURED_LIST',
+    CONTENTS = 'CONTENTS',
+    THANK_YOU = 'THANK_YOU',
+    TABLE = 'TABLE',
+    CHART = 'CHART',
+    TIMELINE = 'TIMELINE',
+}

package/constants/presentation/enums/slide-icon-slot-status.enum.ts

@@ -0,0 +1,6 @@
+export enum SLIDE_ICON_SLOT_STATUS {
+    PENDING = 'PENDING',
+    IN_PROGRESS = 'IN_PROGRESS',
+    READY = 'READY',
+    ERROR = 'ERROR',
+}

package/constants/presentation/enums/slide-image-slot-action.enum.ts

@@ -0,0 +1,4 @@
+export enum SLIDE_IMAGE_SLOT_ACTION {
+    REPLACE = 'REPLACE',
+    GENERATE = 'GENERATE',
+}