@purpleschool/gptbot 0.7.58 → 0.7.59-presentations

package/commands/tools/music/generate-lyrics.command.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export namespace GenerateLyricsCommand {
+    export const RequestSchema = z.object({
+        prompt: z.string(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            title: z.string(),
+            lyrics: z.string(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/music/generate-music.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ToolJobSchema, MusicJobParamsSchema } from '../../../models';
+export namespace MusicCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        params: MusicJobParamsSchema,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: ToolJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/music/get-music-tool-config.command.ts

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

package/commands/tools/music/index.ts

@@ -0,0 +1,11 @@
+export * from './delete-all-music-jobs.command';
+export * from './delete-music-job-by-uuid.command';
+export * from './find-music-job-by-uuid.command';
+export * from './find-music-jobs.command';
+export * from './get-music-tool-config.command';
+export * from './retry-music-job.command';
+export * from './set-reaction-to-music-job.command';
+export * from './generate-music.command';
+export * from './update-music-job-title.command';
+export * from './convert-to-wav.command';
+export * from './generate-lyrics.command';

package/commands/tools/music/retry-music-job.command.ts

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

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { MusicJobSchema } from '../../../models';
+import { USER_REACTION } from '../../../constants';
+
+export namespace SetReactionToMusicJobCommand {
+    export const RequestSchema = z.object({
+        reaction: z.nativeEnum(USER_REACTION).nullable(),
+    });
+    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: MusicJobSchema,
+    });
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/music/update-music-job-title.command.ts

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

package/commands/tools/presentation/build-blank-slide.command.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+
+export namespace BuildBlankSlideCommand {
+    export const RequestSchema = z.object({
+        slideContentType: z.string(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: 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/tools/presentation/generate-and-insert-slide.command.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { SlideSchema } from '../../../models/tools/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/tools/presentation/index.ts

@@ -1,3 +1,4 @@
+export * from './build-blank-slide.command';
 export * from './create-presentation.command';
 export * from './delete-all-user-presentations.command';
 export * from './delete-slide-outline.command';
@@ -7,9 +8,15 @@ 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';

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

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

@@ -5,11 +5,12 @@ export namespace UpdatePresentationCommand {
     export const RequestParamsSchema = z.object({
         uuid: z.string().uuid(),
     });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
 
-    export const RequestBodySchema = z.object({
-        title: z.string(),
-    });
-
+    export const RequestBodySchema = PresentationSchema.pick({
+        title: true,
+        templateId: true,
+    }).partial();
     export type Request = z.infer<typeof RequestBodySchema>;
 
     export const ResponseSchema = z.object({

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { SlideSchema, SlideUpdateSchema } from '../../../models/tools/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/commands/tools/video-editor/delete-all-video-editor-jobs.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export namespace DeleteAllVideoEditorJobsCommand {
+    export const RequestSchema = z.object({});
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.boolean(),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/video-editor/delete-video-editor-job-by-uuid.command.ts

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

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { VideoEditorJobSchema } from '../../../models';
+
+export namespace EditVideoCommand {
+    export const RequestSchema = z.object({
+        modelId: z.string().uuid(),
+        prompt: z.string(),
+        fileId: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: VideoEditorJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/video-editor/find-video-editor-job-by-id.command.ts

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

package/commands/tools/video-editor/find-video-editor-jobs.command.ts

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

package/commands/tools/video-editor/get-video-editor-config.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { VideoEditorModelSchema } from '../../../models';
+
+export namespace GetVideoEditorConfigCommand {
+    export const RequestSchema = z.object({});
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            models: z.array(VideoEditorModelSchema),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/video-editor/index.ts

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

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

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

package/commands/tools/video-editor/set-reaction-to-video-editor-job.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { VideoEditorJobSchema } from '../../../models';
+import { USER_REACTION } from '../../../constants';
+
+export namespace SetReactionToVideoEditorJobCommand {
+    export const RequestSchema = z.object({
+        reaction: z.nativeEnum(USER_REACTION).nullable(),
+    });
+    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: VideoEditorJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/video-editor/update-video-editor-job-title.command.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { VideoEditorJobSchema } from '../../../models';
+
+export namespace UpdateVideoEditorJobTitleCommand {
+    export const RequestSchema = z.object({
+        title: z.string(),
+    });
+    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: VideoEditorJobSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/tools/writer/generate-writer-document-contents.command.ts

@@ -7,6 +7,11 @@ export namespace GenerateWriterDocumentContentsCommand {
     });
     export type RequestParams = z.infer<typeof RequestParamsSchema>;
 
+    export const RequestBodySchema = z.object({
+        modelId: z.string().uuid(),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
     export const ResponseSchema = z.object({
         data: WriterDocumentSchema,
     });

package/commands/tools/writer/index.ts

@@ -13,3 +13,4 @@ export * from './writer-shorten-text.command';
 export * from './writer-fix-errors.command';
 export * from './writer-generate-text.command';
 export * from './export-writer-document-as-docx.command';
+export * from './set-reaction.writer-document.command';

package/commands/tools/writer/set-reaction.writer-document.command.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../../constants';
+import { WriterDocumentSchema } from '../../../models';
+
+export namespace SetReactionWriterDocumentCommand {
+    export const RequestParamsSchema = z.object({
+        uuid: z.string().uuid(),
+    });
+    export type RequestParams = z.infer<typeof RequestParamsSchema>;
+
+    export const RequestBodySchema = z.object({
+        reaction: z.nativeEnum(USER_REACTION),
+    });
+    export type RequestBody = z.infer<typeof RequestBodySchema>;
+
+    export const ResponseSchema = z.object({
+        data: WriterDocumentSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/user/get-aggregated-user-data.command.ts

@@ -8,7 +8,7 @@ export namespace GetAggregatedUserData {
     export type Request = z.infer<typeof RequestSchema>;
 
     export const AggregatedUserSchema = z.object({
-        uuid: z.string().uuid(),
+        userId: z.string().uuid(),
         email: z.string().email().nullable(),
         telegramId: z.number().nullable(),
         lastActivityAt: z.string().datetime(),

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

@@ -14,6 +14,7 @@ export namespace GetMeCommand {
             role: z.nativeEnum(ROLE),
             signupMethod: z.nativeEnum(SIGNUP_METHOD),
             telegramId: z.number().nullable(),
+            webmasterId: z.string().uuid().nullable(),
         }),
     });
 

package/commands/webmaster/confirm-withdrawal.command.ts

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

package/commands/webmaster/create-webmaster.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { WebmasterSchema } from '../../models';
+
+export namespace CreateWebmasterCommand {
+    export const RequestSchema = WebmasterSchema.pick({
+        organization: true,
+        organizationType: true,
+        tin: true,
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: WebmasterSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/webmaster/create-withdrawal-request.command.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+
+export namespace CreateWithdrawalRequestCommand {
+    export const RequestSchema = z.object({
+        amount: z.number().positive(),
+        tgProfile: z.string(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: z.object({
+            isSuccess: z.boolean(),
+        }),
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}