@purpleschool/gptbot-tools 0.0.27 → 0.0.28

package/presentation/models/pptx-export-payload.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/presentation/models/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/presentation/models/presentation-template.schema.ts

@@ -0,0 +1,12 @@
+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(),
+});
+export type PresentationTemplate = z.infer<typeof PresentationTemplateSchema>;

package/presentation/models/presentation.schema.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { PRESENTATION_STAGE } from '../enums';
+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(),
+    userId: z.string().uuid().nullable().optional(),
+    unregisteredUserId: z.string().uuid().nullable().optional(),
+    slideCount: z.number(),
+    isDeleted: z.boolean(),
+    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>;
+
+export const PresentationUpdateSchema = PresentationSchema.pick({
+    title: true,
+});
+export type PresentationUpdate = z.infer<typeof PresentationUpdateSchema>;

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../enums';
+
+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>;

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

@@ -0,0 +1,221 @@
+import { z } from 'zod';
+import { SLIDE_CONTENT_TYPE } from '../enums';
+
+export enum SLIDE_CHART_TYPE {
+    BAR = 'BAR',
+}
+
+export const ImageSlotSchema = z.object({
+    uuid: z
+        .string()
+        .uuid()
+        .describe('Generate a valid uuid for image slot, that will be used for future lookups'),
+    prompt: z.string().describe('Image prompt for slide'),
+});
+export type ImageSlot = z.infer<typeof ImageSlotSchema>;
+
+export const IconSlotSchema = z.object({
+    uuid: z
+        .string()
+        .uuid()
+        .describe('Generate a valid uuid for icon slot, that will be used for future lookups'),
+    prompt: z
+        .string()
+        .describe(
+            'Icons are stored locally. Provide a search query for a fitting icon. MUST BE IN ENGLISH',
+        ),
+});
+export type IconSlot = z.infer<typeof IconSlotSchema>;
+
+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(200),
+    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"'),
+    }),
+});
+export type CoverSlideData = z.infer<typeof CoverSlideDataSchema>;
+
+export const ThankYouSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.THANK_YOU),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(200),
+    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"'),
+    }),
+});
+export type ThankYouSlideData = z.infer<typeof ThankYouSlideDataSchema>;
+
+export const StructuredListSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.STRUCTURED_LIST),
+    title: z.string().describe('Slide title, 2–6 words'),
+    description: z.string().describe('One short framing sentence'),
+    list: z
+        .array(
+            z.object({
+                title: z.string().describe('2–4 words, concrete'),
+                description: z
+                    .string()
+                    .describe('One clear short framing sentence, explains the point, 8–14 words'),
+            }),
+        )
+        .length(4),
+});
+export type StructuredListSlideData = z.infer<typeof StructuredListSlideDataSchema>;
+
+export const TextSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TEXT),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(200),
+    description: z
+        .string()
+        .describe(
+            'Fairly long textual description of the point presented in the title. A couple of paragraphs.',
+        )
+        .min(300)
+        .max(1000),
+});
+export type TextSlideData = z.infer<typeof TextSlideDataSchema>;
+
+export const ContentsSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CONTENTS),
+    title: z
+        .string()
+        .describe(
+            'This slide represents table of contents for the presentation and must be named "Contents" in the presentation language',
+        )
+        .min(10)
+        .max(200),
+    items: z
+        .array(z.string().min(1))
+        .min(1)
+        .describe(
+            'List of slide titles. Must be relevant and generated after all the slides are generated',
+        ),
+});
+export type ContentsSlideData = z.infer<typeof ContentsSlideDataSchema>;
+
+export const ImageSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.IMAGE),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(200),
+    description: z
+        .string()
+        .describe(
+            "Either a short description or a slightly long description of the slide's title depending on the context",
+        )
+        .min(10)
+        .max(500),
+    imageSlot: ImageSlotSchema,
+});
+export type ImageSlideData = z.infer<typeof ImageSlideDataSchema>;
+
+export const SectionBreakSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.SECTION_BREAK),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(200),
+    description: z.string().describe('Description of the slide in about 6 words').min(10).max(200),
+});
+export type SectionBreakSlideData = z.infer<typeof SectionBreakSlideDataSchema>;
+
+export const TableSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.TABLE),
+    title: z
+        .string()
+        .describe('Slide title and table title at the same time in a couple of words')
+        .min(10)
+        .max(200),
+    description: z.string().describe('Description of the table represents').min(10).max(200),
+    table: z.object({
+        columnHeaders: z
+            .array(z.string().min(1).max(50))
+            .min(1)
+            .max(10)
+            .describe('Array of column header labels'),
+        rows: z
+            .array(z.array(z.string().min(1).max(150)))
+            .min(2)
+            .max(10)
+            .describe(
+                'Table rows; each row must have exactly the same number of cells as columnHeaders',
+            ),
+        hasRowHeaders: z.boolean().describe('If table needs special row headers, set this to true'),
+        hasSummaryRow: z.boolean().describe('If table needs a summary row, set this to true'),
+    }),
+});
+export type TableSlideData = z.infer<typeof TableSlideDataSchema>;
+
+// Charts
+export const BarChartSlideDataSchema = z.object({
+    type: z.literal(SLIDE_CHART_TYPE.BAR),
+    categories: z
+        .array(z.string().min(1).max(12))
+        .min(1)
+        .max(12)
+        .describe('Category labels (e.g., months, products, regions)'),
+    series: z
+        .array(
+            z.object({
+                name: z.string().min(1).max(12).describe('Series name for legend'),
+                data: z.array(z.number()).describe('Values corresponding to categories'),
+                type: z
+                    .number()
+                    .min(0)
+                    .max(11)
+                    .describe('Series type. Used to discriminate colors when applying theme'),
+            }),
+        )
+        .min(1)
+        .max(12)
+        .describe('Data series for the chart'),
+    yAxisLabel: z.string().max(40).optional().describe('Y-axis label'),
+    unit: z.string().max(10).optional().describe('Unit symbol (%, $, etc.)'),
+});
+export type BarChartSlideData = z.infer<typeof BarChartSlideDataSchema>;
+
+export const ChartSlideDataSchema = z.object({
+    contentType: z.literal(SLIDE_CONTENT_TYPE.CHART),
+    title: z.string().describe('Slide title in about 6 words').min(10).max(200),
+    description: z.string().describe("Information on slide's topic").min(10).max(400),
+    chart: z.discriminatedUnion('type', [BarChartSlideDataSchema]),
+});
+export type ChartSlideData = z.infer<typeof ChartSlideDataSchema>;
+
+export const SlideContentSchema = z.discriminatedUnion('contentType', [
+    CoverSlideDataSchema,
+    StructuredListSlideDataSchema,
+    TextSlideDataSchema,
+    ContentsSlideDataSchema,
+    SectionBreakSlideDataSchema,
+    ImageSlideDataSchema,
+    ThankYouSlideDataSchema,
+    TableSlideDataSchema,
+    ChartSlideDataSchema,
+]);
+export type SlideContent = z.infer<typeof SlideContentSchema>;

package/presentation/models/slide-icon-slot.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { SLIDE_ICON_SLOT_STATUS } from '../enums';
+
+export const SlideIconSlotSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    alt: z.string(),
+    url: z.string().nullable(),
+    slideId: z.string(),
+    status: z.nativeEnum(SLIDE_ICON_SLOT_STATUS),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/presentation/models/slide-image-slot.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SLIDE_IMAGE_SLOT_STATUS } from '../enums';
+
+export const SlideImageSlotSchema = z.object({
+    uuid: z.string().uuid(),
+    prompt: z.string(),
+    alt: z.string(),
+    url: z.string().nullable(),
+    placeholder: z.string(),
+    slideId: z.string(),
+    status: z.nativeEnum(SLIDE_IMAGE_SLOT_STATUS),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});

package/presentation/models/slide-outline.schema.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { SLIDE_CONTENT_TYPE } from '../enums';
+
+export const SlideOutlineSchema = z.object({
+    uuid: z.string(),
+    order: z.number(),
+    title: z.string().max(80),
+    body: z.string().max(500),
+    contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+    presentationId: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type SlideOutline = z.infer<typeof SlideOutlineSchema>;
+
+export const SlideOutlineUpdateSchema = SlideOutlineSchema.pick({
+    title: true,
+    body: true,
+    contentTypeId: true,
+}).partial();
+export type SlideOutlineUpdate = z.infer<typeof SlideOutlineUpdateSchema>;
+
+export const SlideOutlineBulkUpdateSchema = SlideOutlineSchema.pick({
+    order: true,
+    title: true,
+    body: true,
+    contentTypeId: true,
+    presentationId: true,
+})
+    .extend({
+        uuid: z.string().uuid().optional(),
+    })
+    .array()
+    .min(1, 'Must include at least one slide outline')
+    .refine(
+        (arr) => {
+            const orders = arr.map((s) => s.order);
+            const unique = new Set(orders);
+            if (unique.size !== orders.length) return false;
+            const sorted = [...orders].sort((a, b) => a - b);
+            return sorted.every((val, idx) => val === idx);
+        },
+        {
+            message: 'Slide orders must be unique and sequential starting at 0',
+            path: ['order'],
+        },
+    )
+    .refine(
+        (arr) => {
+            const [firstId, ...rest] = arr.map((s) => s.presentationId);
+            return rest.every((id) => id === firstId);
+        },
+        {
+            message: 'All slide outlines must belong to the same presentation',
+            path: ['presentationId'],
+        },
+    );
+export type SlideOutlineBulkUpdate = z.infer<typeof SlideOutlineBulkUpdateSchema>;

package/presentation/models/slide.schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { SlideContentSchema } from './slide-content.schema';
+import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../enums';
+import { SlideIconSlotSchema } from './slide-icon-slot.schema';
+import { SlideImageSlotSchema } from './slide-image-slot.schema';
+
+export const SlideSchema = z.object({
+    uuid: z.string().uuid(),
+    order: z.number(),
+    contentTypeId: z.nativeEnum(SLIDE_CONTENT_TYPE),
+    layoutId: z.nativeEnum(SLIDE_LAYOUT),
+    content: SlideContentSchema,
+    presentationId: z.string(),
+    iconSlots: z.array(SlideIconSlotSchema),
+    imageSlots: z.array(SlideImageSlotSchema),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+export type Slide = z.infer<typeof SlideSchema>;

package/presentation/queries/find-presentation-by-uuid.query.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { PresentationWithSlidesSchema } from '../models';
+
+export namespace FindPresentationByUuidQuery {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(PresentationWithSlidesSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/queries/find-presentation-outline.query.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { SlideOutlineSchema } from '../models';
+
+export namespace FindPresentationOutlineQuery {
+    export const RequestSchema = z.object({
+        presentationId: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.array(SlideOutlineSchema));
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/queries/find-presentations.query.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { PresentationSchema } from '../models';
+
+export namespace FindPresentationsQuery {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().optional(),
+        unregisteredUserId: z.string().uuid().optional(),
+        title: z.string().optional(),
+        limit: z.coerce.number().min(1).optional(),
+        offset: z.coerce.number().min(0).optional(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            data: z.array(PresentationSchema),
+            page: z.number(),
+            totalPages: z.number(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/presentation/queries/get-presentation-config.query.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common';
+import { PresentationConfigSchema } from '../models';
+
+export namespace GetPresentationConfigQuery {
+    export const ResponseSchema = ICommandResponseSchema(PresentationConfigSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}