@purpleschool/gptbot 0.7.12 → 0.7.14

package/commands/tools/presentation/find-presentation-by-uuid.command.ts

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

package/commands/tools/presentation/find-presentation-outline.command.ts

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

package/commands/tools/presentation/find-presentations.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { PresentationSchema } from '../../../models/tools/presentation';
+
+export namespace FindPresentationsCommand {
+    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(PresentationSchema),
+        totalPages: z.number(),
+        page: z.number(),
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { PresentationSchema } from '../../../models/tools/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/tools/presentation/get-presentation-config.command.ts

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

package/commands/tools/presentation/index.ts

@@ -0,0 +1,15 @@
+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 './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-slide-outline.command';

package/commands/tools/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/tools/presentation/update-presentation-outline.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import {
+    SlideOutlineBulkUpdateSchema,
+    SlideOutlineSchema,
+} from '../../../models/tools/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/tools/presentation/update-presentation.command.ts

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

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

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { SlideOutlineSchema } from '../../../models/tools/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/constants/errors/errors.ts

@@ -1589,4 +1589,70 @@ export const ERRORS = {
         message: 'Вложения изображений и текстовых файлов нельзя использовать вместе',
         httpCode: 400,
     },
+    PRESENTATION_CONFIG_ERROR: {
+        code: 'A338',
+        message: 'Произошла ошибка при получении конфигурации презентации',
+        httpCode: 500,
+    },
+    PRESENTATION_CREATE_ERROR: {
+        code: 'A335',
+        message: 'Произошла ошибка при создании презентации',
+        httpCode: 500,
+    },
+    PRESENTATION_FIND_ERROR: {
+        code: 'A336',
+        message: 'Произошла ошибка при поиске презентации',
+        httpCode: 500,
+    },
+    PRESENTATION_NOT_FOUND: {
+        code: 'A337',
+        message: 'Презентация не найдена',
+        httpCode: 404,
+    },
+    PRESENTATION_SLIDES_GENERATE_ERROR: {
+        code: 'A338',
+        message: 'Произошла ошибка при генерации слайдов презентации',
+        httpCode: 500,
+    },
+    PRESENTATION_UPDATE_SLIDE_OUTLINE_ERROR: {
+        code: 'A339',
+        message: 'Произошла ошибка при редактировании макета слайда',
+        httpCode: 500,
+    },
+    PRESENTATION_REPOSITION_SLIDE_OUTLINE_ERROR: {
+        code: 'A340',
+        message: 'Произошла ошибка при перемещении макета слайда',
+        httpCode: 500,
+    },
+    PRESENTATION_DELETE_SLIDE_OUTLINE_ERROR: {
+        code: 'A341',
+        message: 'Произошла ошибка при удалении макета слайда',
+        httpCode: 500,
+    },
+    PRESENTATION_DELETE_PRESENTATION_ERROR: {
+        code: 'A342',
+        message: 'Произошла ошибка при удалении презентации',
+        httpCode: 500,
+    },
+    PRESENTATION_UPDATE_PRESENTATION_OUTLINE_ERROR: {
+        code: 'A343',
+        message: 'Произошла ошибка при обновлении макета презентации',
+        httpCode: 500,
+    },
+    PRESENTATION_EXPORT_AS_PPTX_ERROR: {
+        code: 'A344',
+        message: 'Произошла ошибка при экспорте презентации в PPTX',
+        httpCode: 500,
+    },
+    PRESENTATION_DELETE_ALL_USER_PRESENTATIONS_ERROR: {
+        code: 'A345',
+        message: 'Произошла ошибка при удалении презентаций пользователя',
+        httpCode: 500,
+    },
+    PRESENTATION_UPDATE_ERROR: {
+        code: 'A346',
+        message: 'Произошла ошибка при обновлении презентации',
+        httpCode: 500,
+    },
 };
+

package/constants/index.ts

@@ -15,6 +15,7 @@ export * from './midjourney';
 export * from './order';
 export * from './page';
 export * from './payment';
+export * from './presentation';
 export * from './product';
 export * from './referral';
 export * from './roles';

package/constants/presentation/enums/index.ts

@@ -0,0 +1,5 @@
+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';

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,11 @@
+export enum SLIDE_CONTENT_TYPE {
+    COVER = 'COVER',
+    TEXT = 'TEXT',
+    SECTION_BREAK = 'SECTION_BREAK',
+    STRUCTURED_LIST = 'STRUCTURED_LIST',
+    CONTENTS = 'CONTENTS',
+    IMAGE = 'IMAGE',
+    THANK_YOU = 'THANK_YOU',
+    TABLE = 'TABLE',
+    CHART = 'CHART',
+}

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.status.enum.ts

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

package/constants/presentation/enums/slide-layout.enum.ts

@@ -0,0 +1,4 @@
+export enum SLIDE_LAYOUT {
+    TYPE_1 = 'TYPE_1',
+    TYPE_2 = 'TYPE_2',
+}

package/constants/presentation/index.ts

@@ -0,0 +1,2 @@
+export * from './enums';
+export * from './maps';

package/constants/presentation/maps/index.ts

@@ -0,0 +1 @@
+export * from './slide-layout-map.constant';

package/constants/presentation/maps/slide-layout-map.constant.ts

@@ -0,0 +1,14 @@
+import { SLIDE_CONTENT_TYPE } from '../enums';
+import { SLIDE_LAYOUT } from '../enums/slide-layout.enum';
+
+export const SLIDE_LAYOUT_MAP = new Map<SLIDE_CONTENT_TYPE, SLIDE_LAYOUT[]>([
+    [SLIDE_CONTENT_TYPE.COVER, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.STRUCTURED_LIST, [SLIDE_LAYOUT.TYPE_1, SLIDE_LAYOUT.TYPE_2]],
+    [SLIDE_CONTENT_TYPE.TEXT, [SLIDE_LAYOUT.TYPE_1, SLIDE_LAYOUT.TYPE_2]],
+    [SLIDE_CONTENT_TYPE.SECTION_BREAK, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.CONTENTS, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.IMAGE, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.THANK_YOU, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.TABLE, [SLIDE_LAYOUT.TYPE_1]],
+    [SLIDE_CONTENT_TYPE.CHART, [SLIDE_LAYOUT.TYPE_1]],
+]);

package/models/tools/index.ts

@@ -1,3 +1,4 @@
+export * from './language';
 export * from './paraphrase';
 export * from './stt';
 export * from './tts';

package/models/tools/language/index.ts

@@ -0,0 +1 @@
+export * from './language.schema';

package/models/tools/language/language.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const LanguageSchema = z.object({
+    uuid: z.string(),
+    name: z.string(),
+    order: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/models/tools/presentation/index.ts

@@ -0,0 +1,7 @@
+export * from './pptx-export-payload.schema';
+export * from './presentation.schema';
+export * from './slide-content-type.schema';
+export * from './slide-outline.schema';
+export * from './slide.schema';
+export * from './slide-content.schema';
+export * from './presentation-config.schema';

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

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+
+export enum PPTX_SHAPE_TYPE {
+    TEXT_BOX = 'text_box',
+    PICTURE_BOX = 'picture_box',
+    CUSTOM_SHAPE = 'custom_shape',
+    TABLE = 'table',
+}
+
+export enum PPTX_H_ALIGN {
+    LEFT = 'left',
+    CENTER = 'center',
+    RIGHT = 'right',
+    JUSTIFY = 'justify',
+}
+
+export enum PPTX_V_ALIGN {
+    TOP = 'top',
+    MIDDLE = 'middle',
+    BOTTOM = 'bottom',
+}
+
+export enum PPTX_OBJECT_FIT {
+    COVER = 'cover',
+    CONTAIN = 'contain',
+    CROP = 'crop',
+}
+
+export enum PPTX_BORDER_TYPE {
+    SOLID = 'solid',
+    NONE = 'none',
+    DASH = 'dash',
+}
+
+export enum PPTX_FILL_TYPE {
+    SOLID = 'solid',
+    NONE = 'none',
+}
+
+export enum PPTX_SHADOW_TYPE {
+    OUTER = 'outer',
+    INNER = 'inner',
+    NONE = 'none',
+}
+
+export enum PPTX_CUSTOM_SHAPE_TYPE {
+    ROUND_RECT = 'roundRect',
+}
+
+export const PPTXShadowSchema = z.object({
+    type: z.nativeEnum(PPTX_SHADOW_TYPE),
+    opacity: z.number().min(0).max(100).optional().describe('percents, range 0-100'),
+    color: z.string().optional().describe('hex color'),
+    blur: z.number().min(0).max(100).optional().describe('degrees, range 0-100'),
+    angle: z.number().min(0).max(359).optional().describe('degrees, range 0-359'),
+    offset: z.number().min(0).max(200).optional().describe('points, range 0-200'),
+    rotateWithShape: z.boolean().optional().describe('whether or not to rotate shadow with shape'),
+});
+
+export const PPTXFillSchema = z.object({
+    color: z.string(),
+    type: z.nativeEnum(PPTX_FILL_TYPE),
+    transparency: z.number().min(0).max(100).optional().describe('percents, range 0-100'),
+    alpha: z.number().min(0).max(1).optional().describe('range 0-1'),
+});
+
+export const PPTXMarginSchema = z.union([
+    z.number(),
+    z.tuple([z.number(), z.number(), z.number(), z.number()]),
+]);
+export type PPTXMargin = z.infer<typeof PPTXMarginSchema>;
+
+// Common
+export const PPTXPositionSchema = z.object({
+    height: z.number(),
+    width: z.number(),
+    top: z.number(),
+    left: z.number(),
+});
+export type PPTXPosition = z.infer<typeof PPTXPositionSchema>;
+
+export const PPTXFontSchema = z.object({
+    bold: z.boolean().optional(),
+    color: z.string(),
+    name: z.string(),
+    size: z.number(),
+    lineHeight: z
+        .union([
+            z.object({
+                percent: z.number(),
+            }),
+            z.object({
+                px: z.number(),
+            }),
+        ])
+        .optional(),
+});
+export type PPTXFont = z.infer<typeof PPTXFontSchema>;
+
+// Textual
+export const PPTXParagraphSchema = z.object({
+    alignment: z.nativeEnum(PPTX_H_ALIGN),
+    font: PPTXFontSchema,
+    valign: z.nativeEnum(PPTX_V_ALIGN).optional(),
+    margin: PPTXMarginSchema.optional(),
+    rotate: z.number().optional(),
+    text: z.string(),
+});
+export type PPTXParagraph = z.infer<typeof PPTXParagraphSchema>;
+
+export const PPTXTextBoxSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.TEXT_BOX),
+    position: PPTXPositionSchema,
+
+    paragraphs: z.array(PPTXParagraphSchema),
+});
+export type PPTXTextBox = z.infer<typeof PPTXTextBoxSchema>;
+
+// Picture
+export const PPTXPictureBoxSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.PICTURE_BOX),
+    position: PPTXPositionSchema,
+    borderRadius: z.array(z.number()).optional(),
+    objectFit: z.nativeEnum(PPTX_OBJECT_FIT),
+    data: z.union([
+        z.object({
+            base64: z
+                .string()
+                .describe('Base64 encoded image in "image/{mimeType};base64,{bas64}" format'),
+        }),
+        z.object({
+            path: z.string().describe('URL to image'),
+        }),
+    ]),
+});
+export type PPTXPictureBox = z.infer<typeof PPTXPictureBoxSchema>;
+
+// CustomShape
+export const PPTXCustomShapeSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.CUSTOM_SHAPE),
+    customShapeType: z.nativeEnum(PPTX_CUSTOM_SHAPE_TYPE).optional(),
+    position: PPTXPositionSchema,
+    borderRadius: z.number(),
+    fill: PPTXFillSchema.optional(),
+    shadow: PPTXShadowSchema.optional(),
+});
+export type PPTXCustomShape = z.infer<typeof PPTXCustomShapeSchema>;
+
+// Table
+export const PPTXTableCellSchema = z.object({
+    text: z.string().optional(),
+    font: PPTXFontSchema.optional(),
+    fill: z
+        .object({
+            color: z.string(),
+            type: z.nativeEnum(PPTX_FILL_TYPE),
+            transparency: z.number().min(0).max(100).optional().describe('percents, range 0-100'),
+        })
+        .optional(),
+    align: z.nativeEnum(PPTX_H_ALIGN).optional(),
+    valign: z.nativeEnum(PPTX_V_ALIGN).optional(),
+    colspan: z.number().int().optional(),
+    rowspan: z.number().int().optional(),
+    margin: PPTXMarginSchema.optional(),
+});
+export type PPTXTableCell = z.infer<typeof PPTXTableCellSchema>;
+
+export const PPTXTableRowSchema = z.array(PPTXTableCellSchema);
+export type PPTXTableRow = z.infer<typeof PPTXTableRowSchema>;
+
+export const PPTXTableShapeSchema = z.object({
+    type: z.literal(PPTX_SHAPE_TYPE.TABLE),
+    position: PPTXPositionSchema,
+    rows: z.array(PPTXTableRowSchema),
+    columnWidths: z.array(z.number()).optional(),
+    headerRows: z.number().int().min(0).optional(),
+    border: z.object({
+        type: z.nativeEnum(PPTX_BORDER_TYPE),
+        color: z.string(),
+        px: z.number(),
+    }),
+});
+export type PPTXTableShape = z.infer<typeof PPTXTableShapeSchema>;
+
+// Overview
+
+export const PPTXShapeSchema = z.discriminatedUnion('type', [
+    PPTXTextBoxSchema,
+    PPTXPictureBoxSchema,
+    PPTXCustomShapeSchema,
+    PPTXTableShapeSchema,
+]);
+export type PPTXShape = z.infer<typeof PPTXShapeSchema>;
+
+export const SlideBackground = z.union([
+    PPTXFillSchema,
+    z.object({
+        path: z.string(),
+    }),
+]);
+export type SlideBackground = z.infer<typeof SlideBackground>;
+
+export const PPTXSlideSchema = z.object({
+    background: SlideBackground.optional(),
+    shapes: z.array(PPTXShapeSchema),
+});
+export type PPTXSlide = z.infer<typeof PPTXSlideSchema>;
+
+export const PPTXExportPayloadSchema = z.object({
+    slides: z.array(PPTXSlideSchema),
+});
+export type PPTXExportPayload = z.infer<typeof PPTXExportPayloadSchema>;

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { SlideContentTypeSchema } from './slide-content-type.schema';
+import { LanguageSchema } from '../language';
+import { PresentationTemplateSchema } from './presentation-template.schema';
+
+export const PresentationConfigSchema = z.object({
+    slideContentTypes: z.array(SlideContentTypeSchema),
+    languages: z.array(LanguageSchema),
+    templates: z.array(PresentationTemplateSchema),
+    slideGenerationPrice: z.number(),
+    maxSlides: z.number(),
+    minSlides: z.number(),
+    maxSlideOutlineLength: z.number(),
+    maxPromptLength: z.number(),
+});
+export type PresentationConfig = z.infer<typeof PresentationConfigSchema>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const PresentationTemplateSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    image: z.string(),
+    order: z.number(),
+    imagePlaceholder: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { PRESENTATION_STAGE } from '../../../constants';
+import { SlideOutlineSchema } from './slide-outline.schema';
+import { SlideSchema } from './slide.schema';
+
+export const PresentationSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    stage: z.nativeEnum(PRESENTATION_STAGE),
+    title: z.string(),
+    thumbnail: z.string(),
+    languageId: z.string(),
+    templateId: z.string(),
+    downloadUrl: z.string().nullable(),
+    slideCount: z.number(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type Presentation = z.infer<typeof PresentationSchema>;
+
+export const PresentationWithSlidesSchema = PresentationSchema.extend({
+    outline: z.array(SlideOutlineSchema),
+    slides: z.array(SlideSchema),
+});
+export type PresentationWithSlides = z.infer<typeof PresentationWithSlidesSchema>;

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

@@ -0,0 +1,13 @@
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../../../constants';
+import { z } from 'zod';
+
+export const SlideContentTypeSchema = z.object({
+    id: z.nativeEnum(SLIDE_CONTENT_TYPE),
+    title: z.string(),
+    layouts: z.array(z.nativeEnum(SLIDE_LAYOUT)),
+    order: z.number(),
+    icon: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type SlideContentType = z.infer<typeof SlideContentTypeSchema>;