@purpleschool/gptbot-tools 0.2.75 → 0.2.77

package/build/presentation/commands/delete-all-user-presentations.command.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace DeleteAllUserPresentationsCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/presentation/commands/delete-all-user-presentations.command.js

@@ -6,8 +6,8 @@ const command_response_schema_1 = require("../../common/models/command-response.
 var DeleteAllUserPresentationsCommand;
 (function (DeleteAllUserPresentationsCommand) {
     DeleteAllUserPresentationsCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
     });
     DeleteAllUserPresentationsCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
 })(DeleteAllUserPresentationsCommand || (exports.DeleteAllUserPresentationsCommand = DeleteAllUserPresentationsCommand = {}));

package/build/presentation/commands/delete-presentation.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace DeletePresentationCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/presentation/commands/delete-presentation.command.js

@@ -6,9 +6,9 @@ const common_1 = require("../../common");
 var DeletePresentationCommand;
 (function (DeletePresentationCommand) {
     DeletePresentationCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
     });
     DeletePresentationCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.boolean());
 })(DeletePresentationCommand || (exports.DeletePresentationCommand = DeletePresentationCommand = {}));

package/build/presentation/commands/delete-slide-outline.command.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare namespace DeleteSlideOutlineCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
-        slideOutlineId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
+        slideOutlineId: z.ZodUUID;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/presentation/commands/delete-slide-outline.command.js

@@ -6,10 +6,10 @@ const common_1 = require("../../common");
 var DeleteSlideOutlineCommand;
 (function (DeleteSlideOutlineCommand) {
     DeleteSlideOutlineCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
-        slideOutlineId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        slideOutlineId: zod_1.z.uuid(),
     });
     DeleteSlideOutlineCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.boolean());
 })(DeleteSlideOutlineCommand || (exports.DeleteSlideOutlineCommand = DeleteSlideOutlineCommand = {}));

package/build/presentation/commands/export-as-pptx.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace ExportAsPPTXCommand {
     const RequestSchema: z.ZodObject<{
-        presentationId: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        presentationId: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         data: z.ZodObject<{
             slides: z.ZodArray<z.ZodObject<{
                 background: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{

package/build/presentation/commands/export-as-pptx.command.js

@@ -7,9 +7,9 @@ const common_1 = require("../../common");
 var ExportAsPPTXCommand;
 (function (ExportAsPPTXCommand) {
     ExportAsPPTXCommand.RequestSchema = zod_1.z.object({
-        presentationId: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         data: models_1.PPTXExportPayloadSchema,
     });
     ExportAsPPTXCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.object({

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

@@ -3,10 +3,10 @@ import { SLIDE_CONTENT_TYPE, SLIDE_LAYOUT } from '../enums';
 export declare namespace GenerateAndInsertSlideCommand {
     const RequestSchema: z.ZodObject<{
         locale: z.ZodEnum<typeof import("@purpleschool/rugpt-lib-common").LOCALE>;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         userBalance: z.ZodNumber;
-        presentationId: z.ZodString;
+        presentationId: z.ZodUUID;
         contentTypeId: z.ZodEnum<typeof SLIDE_CONTENT_TYPE>;
         prompt: z.ZodOptional<z.ZodString>;
         title: z.ZodString;

package/build/presentation/commands/generate-and-insert-slide.command.js

@@ -9,15 +9,15 @@ var GenerateAndInsertSlideCommand;
 (function (GenerateAndInsertSlideCommand) {
     GenerateAndInsertSlideCommand.RequestSchema = zod_1.z.object({
         locale: common_1.LocaleSchema,
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         userBalance: zod_1.z.number(),
-        presentationId: zod_1.z.string().uuid(),
-        contentTypeId: zod_1.z.nativeEnum(enums_1.SLIDE_CONTENT_TYPE),
+        presentationId: zod_1.z.uuid(),
+        contentTypeId: zod_1.z.enum(enums_1.SLIDE_CONTENT_TYPE),
         prompt: zod_1.z.string().min(1).max(1000).optional(),
         title: zod_1.z.string().max(80),
         position: zod_1.z.number().int().min(0),
-        layoutId: zod_1.z.nativeEnum(enums_1.SLIDE_LAYOUT).optional(),
+        layoutId: zod_1.z.enum(enums_1.SLIDE_LAYOUT).optional(),
         mock: zod_1.z.boolean().optional(),
     });
     GenerateAndInsertSlideCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.SlideSchema.array());

package/build/presentation/commands/generate-presentation-outline.command.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare namespace GeneratePresentationOutlineCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
-        languageId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
+        languageId: z.ZodUUID;
         slideCount: z.ZodNumber;
         prompt: z.ZodString;
         mock: z.ZodOptional<z.ZodBoolean>;

package/build/presentation/commands/generate-presentation-outline.command.js

@@ -7,10 +7,10 @@ const models_1 = require("../models");
 var GeneratePresentationOutlineCommand;
 (function (GeneratePresentationOutlineCommand) {
     GeneratePresentationOutlineCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
-        languageId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        languageId: zod_1.z.uuid(),
         slideCount: zod_1.z.number(),
         prompt: zod_1.z.string(),
         mock: zod_1.z.boolean().optional(),

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

@@ -2,15 +2,15 @@ import { z } from 'zod';
 export declare namespace GenerateSlidesCommand {
     const RequestSchema: z.ZodObject<{
         locale: z.ZodEnum<typeof import("@purpleschool/rugpt-lib-common").LOCALE>;
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        tokenReservationId: z.ZodString;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        tokenReservationId: z.ZodUUID;
         precalculatedPrice: z.ZodNumber;
         titlePage: z.ZodNullable<z.ZodOptional<z.ZodObject<{
             author: z.ZodNullable<z.ZodOptional<z.ZodString>>;
             createdAt: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
-            email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+            email: z.ZodNullable<z.ZodOptional<z.ZodEmail>>;
         }, z.core.$strip>>>;
         mock: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;

package/build/presentation/commands/generate-slides.command.js

@@ -8,10 +8,10 @@ var GenerateSlidesCommand;
 (function (GenerateSlidesCommand) {
     GenerateSlidesCommand.RequestSchema = zod_1.z.object({
         locale: common_1.LocaleSchema,
-        uuid: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        tokenReservationId: zod_1.z.string().uuid(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        tokenReservationId: zod_1.z.uuid(),
         precalculatedPrice: zod_1.z.number(),
         titlePage: models_1.PresentationTitlePageSchema.optional().nullable(),
         mock: zod_1.z.boolean().optional(),

package/build/presentation/commands/get-presentation-slides-generation-price.command.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 export declare namespace GetPresentationSlidesGenerationPriceCommand {
     const RequestSchema: z.ZodObject<{
         slideCount: z.ZodNumber;
-        templateId: z.ZodString;
+        templateId: z.ZodUUID;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseDataSchema: z.ZodObject<{

package/build/presentation/commands/get-presentation-slides-generation-price.command.js

@@ -7,7 +7,7 @@ var GetPresentationSlidesGenerationPriceCommand;
 (function (GetPresentationSlidesGenerationPriceCommand) {
     GetPresentationSlidesGenerationPriceCommand.RequestSchema = zod_1.z.object({
         slideCount: zod_1.z.number().int().min(1),
-        templateId: zod_1.z.string().uuid(),
+        templateId: zod_1.z.uuid(),
     });
     GetPresentationSlidesGenerationPriceCommand.ResponseDataSchema = zod_1.z.object({
         price: zod_1.z.number(),

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace PresentationGenerateReportCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
         userBalance: z.ZodNumber;
         mock: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;

package/build/presentation/commands/presentation-generate-report.command.js

@@ -6,9 +6,9 @@ const common_1 = require("../../common");
 var PresentationGenerateReportCommand;
 (function (PresentationGenerateReportCommand) {
     PresentationGenerateReportCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
         userBalance: zod_1.z.number(),
         mock: zod_1.z.boolean().optional(),
     });

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

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare namespace PresentationParaphraseCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
-        slideId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
+        slideId: z.ZodUUID;
         selectionText: z.ZodString;
         userBalance: z.ZodNumber;
         mock: z.ZodOptional<z.ZodBoolean>;

package/build/presentation/commands/presentation-paraphrase.command.js

@@ -6,10 +6,10 @@ const common_1 = require("../../common");
 var PresentationParaphraseCommand;
 (function (PresentationParaphraseCommand) {
     PresentationParaphraseCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
-        slideId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        slideId: zod_1.z.uuid(),
         selectionText: zod_1.z.string(),
         userBalance: zod_1.z.number(),
         mock: zod_1.z.boolean().optional(),

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

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare namespace RepositionSlideOutlineCommand {
     const RequestSchema: z.ZodObject<{
-        presentationId: z.ZodString;
-        slideOutlineId: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        presentationId: z.ZodUUID;
+        slideOutlineId: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         newPosition: z.ZodNumber;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/presentation/commands/reposition-slide-outline.command.js

@@ -6,10 +6,10 @@ const common_1 = require("../../common");
 var RepositionSlideOutlineCommand;
 (function (RepositionSlideOutlineCommand) {
     RepositionSlideOutlineCommand.RequestSchema = zod_1.z.object({
-        presentationId: zod_1.z.string().uuid(),
-        slideOutlineId: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        slideOutlineId: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         newPosition: zod_1.z.number(),
     });
     RepositionSlideOutlineCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.boolean());

package/build/presentation/commands/reposition-slide.command.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare namespace RepositionSlideCommand {
     const RequestSchema: z.ZodObject<{
-        presentationId: z.ZodString;
-        slideId: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        presentationId: z.ZodUUID;
+        slideId: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         newPosition: z.ZodNumber;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/presentation/commands/reposition-slide.command.js

@@ -6,10 +6,10 @@ const common_1 = require("../../common");
 var RepositionSlideCommand;
 (function (RepositionSlideCommand) {
     RepositionSlideCommand.RequestSchema = zod_1.z.object({
-        presentationId: zod_1.z.string().uuid(),
-        slideId: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        slideId: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         newPosition: zod_1.z.number(),
     });
     RepositionSlideCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.boolean());

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

@@ -2,9 +2,9 @@ import { z } from 'zod';
 import { USER_REACTION } from '../../common';
 export declare namespace SetReactionToPresentationCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        uuid: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        uuid: z.ZodUUID;
         reaction: z.ZodNullable<z.ZodEnum<typeof USER_REACTION>>;
         dislikeReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;

package/build/presentation/commands/set-reaction-to-presentation.command.js

@@ -8,10 +8,10 @@ var SetReactionToPresentationCommand;
 (function (SetReactionToPresentationCommand) {
     SetReactionToPresentationCommand.RequestSchema = zod_1.z
         .object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        uuid: zod_1.z.string().uuid(),
-        reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        uuid: zod_1.z.uuid(),
+        reaction: zod_1.z.enum(common_1.USER_REACTION).nullable(),
         dislikeReason: zod_1.z.string().nullable().default(null),
     })
         .refine((data) => {

package/build/presentation/commands/update-presentation-favorite.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdatePresentationFavoriteCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
         isFavorite: z.ZodBoolean;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/presentation/commands/update-presentation-favorite.command.js

@@ -7,9 +7,9 @@ const common_1 = require("../../common");
 var UpdatePresentationFavoriteCommand;
 (function (UpdatePresentationFavoriteCommand) {
     UpdatePresentationFavoriteCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
         isFavorite: zod_1.z.boolean(),
     });
     UpdatePresentationFavoriteCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.PresentationSchema);

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

@@ -1,16 +1,16 @@
 import { z } from 'zod';
 export declare namespace UpdatePresentationOutlineCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
         data: z.ZodArray<z.ZodObject<{
             order: z.ZodNumber;
             title: z.ZodString;
             body: z.ZodString;
             contentTypeId: z.ZodEnum<typeof import("..").SLIDE_CONTENT_TYPE>;
             presentationId: z.ZodString;
-            uuid: z.ZodOptional<z.ZodString>;
+            uuid: z.ZodOptional<z.ZodUUID>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/presentation/commands/update-presentation-outline.command.js

@@ -7,9 +7,9 @@ const common_1 = require("../../common");
 var UpdatePresentationOutlineCommand;
 (function (UpdatePresentationOutlineCommand) {
     UpdatePresentationOutlineCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
         data: models_1.SlideOutlineBulkUpdateSchema,
     });
     UpdatePresentationOutlineCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.array(models_1.SlideOutlineSchema));

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

@@ -1,15 +1,15 @@
 import { z } from 'zod';
 export declare namespace UpdatePresentationSlidesCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
         data: z.ZodArray<z.ZodObject<{
             order: z.ZodNumber;
             contentTypeId: z.ZodEnum<typeof import("..").SLIDE_CONTENT_TYPE>;
             layoutId: z.ZodEnum<typeof import("..").SLIDE_LAYOUT>;
             presentationId: z.ZodString;
-            uuid: z.ZodOptional<z.ZodString>;
+            uuid: z.ZodOptional<z.ZodUUID>;
             content: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 contentType: z.ZodLiteral<import("..").SLIDE_CONTENT_TYPE.COVER>;
                 title: z.ZodString;

package/build/presentation/commands/update-presentation-slides.command.js

@@ -7,9 +7,9 @@ const common_1 = require("../../common");
 var UpdatePresentationSlidesCommand;
 (function (UpdatePresentationSlidesCommand) {
     UpdatePresentationSlidesCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
         data: models_1.SlideBulkUpdateSchema,
     });
     UpdatePresentationSlidesCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.array(models_1.SlideSchema));

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

@@ -1,16 +1,16 @@
 import { z } from 'zod';
 export declare namespace UpdatePresentationCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
         data: z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
             templateId: z.ZodOptional<z.ZodString>;
             titlePage: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 author: z.ZodNullable<z.ZodOptional<z.ZodString>>;
                 createdAt: z.ZodNullable<z.ZodOptional<z.ZodDate>>;
-                email: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+                email: z.ZodNullable<z.ZodOptional<z.ZodEmail>>;
             }, z.core.$strip>>>;
         }, z.core.$strip>;
     }, z.core.$strip>;

package/build/presentation/commands/update-presentation.command.js

@@ -7,9 +7,9 @@ const common_1 = require("../../common");
 var UpdatePresentationCommand;
 (function (UpdatePresentationCommand) {
     UpdatePresentationCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
         data: models_1.PresentationUpdateSchema,
     });
     UpdatePresentationCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.PresentationSchema);

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

@@ -2,14 +2,14 @@ import { z } from 'zod';
 import { SLIDE_IMAGE_SLOT_ACTION } from '../enums';
 export declare namespace UpdateSlideImageSlotCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
-        slideId: z.ZodString;
-        slotId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
+        slideId: z.ZodUUID;
+        slotId: z.ZodOptional<z.ZodUUID>;
         payload: z.ZodDiscriminatedUnion<[z.ZodObject<{
             action: z.ZodLiteral<SLIDE_IMAGE_SLOT_ACTION.REPLACE>;
-            url: z.ZodString;
+            url: z.ZodURL;
         }, z.core.$strip>, z.ZodObject<{
             action: z.ZodLiteral<SLIDE_IMAGE_SLOT_ACTION.GENERATE>;
             prompt: z.ZodOptional<z.ZodString>;

package/build/presentation/commands/update-slide-image-slot.command.js

@@ -9,7 +9,7 @@ var UpdateSlideImageSlotCommand;
 (function (UpdateSlideImageSlotCommand) {
     const ReplacePayload = zod_1.z.object({
         action: zod_1.z.literal(enums_1.SLIDE_IMAGE_SLOT_ACTION.REPLACE),
-        url: zod_1.z.string().url(),
+        url: zod_1.z.url(),
     });
     const GeneratePayload = zod_1.z.object({
         action: zod_1.z.literal(enums_1.SLIDE_IMAGE_SLOT_ACTION.GENERATE),
@@ -20,11 +20,11 @@ var UpdateSlideImageSlotCommand;
         GeneratePayload,
     ]);
     UpdateSlideImageSlotCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
-        slideId: zod_1.z.string().uuid(),
-        slotId: zod_1.z.string().uuid().optional(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        slideId: zod_1.z.uuid(),
+        slotId: zod_1.z.uuid().optional(),
         payload: UpdateImageSlotPayload,
         userBalance: zod_1.z.number(),
         mock: zod_1.z.boolean().optional(),

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

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare namespace UpdateSlideOutlineCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        presentationId: z.ZodString;
-        slideOutlineId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        presentationId: z.ZodUUID;
+        slideOutlineId: z.ZodUUID;
         data: z.ZodObject<{
             title: z.ZodOptional<z.ZodString>;
             body: z.ZodOptional<z.ZodString>;

package/build/presentation/commands/update-slide-outline.command.js

@@ -7,10 +7,10 @@ const common_1 = require("../../common");
 var UpdateSlideOutlineCommand;
 (function (UpdateSlideOutlineCommand) {
     UpdateSlideOutlineCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        presentationId: zod_1.z.string().uuid(),
-        slideOutlineId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        presentationId: zod_1.z.uuid(),
+        slideOutlineId: zod_1.z.uuid(),
         data: models_1.SlideOutlineUpdateSchema,
     });
     UpdateSlideOutlineCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.SlideOutlineSchema);