@purpleschool/gptbot-tools 0.0.105 → 0.0.108

package/build/image-editor/commands/set-reaction-to-image-editor-job.command.js

@@ -7,11 +7,21 @@ const models_1 = require("../models");
 const common_1 = require("../../common");
 var SetReactionToImageEditorJobCommand;
 (function (SetReactionToImageEditorJobCommand) {
-    SetReactionToImageEditorJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToImageEditorJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToImageEditorJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.ImageEditorJobSchema);
 })(SetReactionToImageEditorJobCommand || (exports.SetReactionToImageEditorJobCommand = SetReactionToImageEditorJobCommand = {}));

package/build/image-editor/models/image-editor-job.schema.js

@@ -13,6 +13,7 @@ exports.ImageEditorJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     prompt: zod_1.z.string(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     externalId: zod_1.z.string().nullable(),
     title: zod_1.z.string(),
     status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),

package/build/image-generation/commands/image-generation-model/get-image-generation-model-by-uuid.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetImageGenerationModelByUuidCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+const common_1 = require("../../../common");
+var GetImageGenerationModelByUuidCommand;
+(function (GetImageGenerationModelByUuidCommand) {
+    GetImageGenerationModelByUuidCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    GetImageGenerationModelByUuidCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.ImageGenerationModelSchema);
+})(GetImageGenerationModelByUuidCommand || (exports.GetImageGenerationModelByUuidCommand = GetImageGenerationModelByUuidCommand = {}));

package/build/image-generation/commands/image-generation-model/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-image-generation-model-by-uuid.command"), exports);

package/build/image-generation/commands/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./soft-delete-image-generation-job-by-uuid.command"), expo
 __exportStar(require("./soft-delete-image-generation-jobs-by-criteria.command"), exports);
 __exportStar(require("./set-reaction-to-image-generation-job.command"), exports);
 __exportStar(require("./update-image-generation-job-title.command"), exports);
+__exportStar(require("./image-generation-model"), exports);

package/build/image-generation/commands/set-reaction-to-image-generation-job.command.js

@@ -7,11 +7,21 @@ const command_response_schema_1 = require("../../common/models/command-response.
 const models_1 = require("../models");
 var SetReactionToImageGenerationJobCommand;
 (function (SetReactionToImageGenerationJobCommand) {
-    SetReactionToImageGenerationJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToImageGenerationJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToImageGenerationJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.ImageGenerationJobSchema);
 })(SetReactionToImageGenerationJobCommand || (exports.SetReactionToImageGenerationJobCommand = SetReactionToImageGenerationJobCommand = {}));

package/build/image-generation/enums/image-generation-model-strategy.enum.js

@@ -20,4 +20,6 @@ var IMAGE_GENERATION_MODEL_STRATEGY;
     IMAGE_GENERATION_MODEL_STRATEGY["NANO_BANANA_IMAGE_GENERATION"] = "NANO_BANANA_IMAGE_GENERATION";
     // Flux
     IMAGE_GENERATION_MODEL_STRATEGY["KIE_FLUX_IMAGE_GENERATION"] = "KIE_FLUX_IMAGE_GENERATION";
+    // Z-Image
+    IMAGE_GENERATION_MODEL_STRATEGY["KIE_Z_IMAGE_GENERATION"] = "KIE_Z_IMAGE_GENERATION";
 })(IMAGE_GENERATION_MODEL_STRATEGY || (exports.IMAGE_GENERATION_MODEL_STRATEGY = IMAGE_GENERATION_MODEL_STRATEGY = {}));

package/build/image-generation/models/image-generation-job.schema.js

@@ -19,6 +19,7 @@ exports.ImageGenerationJobSchema = zod_1.z.object({
     error: zod_1.z.string().nullable(),
     price: zod_1.z.number(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     externalId: zod_1.z.string().nullable(),
     params: exports.ImageGenerationJobParamsSchema,
     output: zod_1.z.array(zod_1.z.string()),

package/build/image-generation/routes/image-generation.http.routes.js

@@ -6,4 +6,5 @@ exports.IMAGE_GENERATION_ROUTES = {
     KIE_MIDJOURNEY_CALLBACK: 'kie/midjourney/callback',
     KIE_NANO_BANANA_CALLBACK: 'kie/nano-banana/callback',
     KIE_FLUX_CALLBACK: 'kie/flux/callback',
+    KIE_Z_CALLBACK: 'kie/z-image/callback',
 };

package/build/music/commands/set-reaction-to-music-job.command.js

@@ -7,11 +7,21 @@ const music_job_schema_1 = require("../models/music-job.schema");
 const common_1 = require("../../common");
 var SetReactionToMusicJobCommand;
 (function (SetReactionToMusicJobCommand) {
-    SetReactionToMusicJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToMusicJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToMusicJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(music_job_schema_1.MusicJobSchema);
 })(SetReactionToMusicJobCommand || (exports.SetReactionToMusicJobCommand = SetReactionToMusicJobCommand = {}));

package/build/music/models/music-job.schema.js

@@ -34,6 +34,7 @@ exports.MusicJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     prompt: zod_1.z.string(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     externalId: zod_1.z.string().nullable(),
     title: zod_1.z.string(),
     status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),

package/build/paraphrase/commands/set-reaction-to-paraphrase-job.command.js

@@ -7,11 +7,21 @@ const paraphrase_job_schema_1 = require("../models/paraphrase-job.schema");
 const common_1 = require("../../common");
 var SetReactionToParaphraseJobCommand;
 (function (SetReactionToParaphraseJobCommand) {
-    SetReactionToParaphraseJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToParaphraseJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToParaphraseJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(paraphrase_job_schema_1.ParaphraseJobSchema);
 })(SetReactionToParaphraseJobCommand || (exports.SetReactionToParaphraseJobCommand = SetReactionToParaphraseJobCommand = {}));

package/build/paraphrase/models/paraphrase-job.schema.js

@@ -17,6 +17,7 @@ exports.ParaphraseJobSchema = zod_1.z.object({
     title: zod_1.z.string(),
     error: zod_1.z.string().nullable(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     typeId: zod_1.z.string(),
     styleId: zod_1.z.string(),
     intensity: zod_1.z.nativeEnum(enums_1.PARAPHRASING_INTENSITY),

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

@@ -6,11 +6,21 @@ const common_1 = require("../../common");
 const models_1 = require("../models");
 var SetReactionToPresentationCommand;
 (function (SetReactionToPresentationCommand) {
-    SetReactionToPresentationCommand.RequestSchema = zod_1.z.object({
+    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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToPresentationCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.PresentationSchema);
 })(SetReactionToPresentationCommand || (exports.SetReactionToPresentationCommand = SetReactionToPresentationCommand = {}));

package/build/presentation/models/presentation.schema.js

@@ -5,6 +5,7 @@ const zod_1 = require("zod");
 const enums_1 = require("../enums");
 const slide_outline_schema_1 = require("./slide-outline.schema");
 const slide_schema_1 = require("./slide.schema");
+const common_1 = require("../../common");
 exports.PresentationSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     prompt: zod_1.z.string(),
@@ -14,6 +15,8 @@ exports.PresentationSchema = zod_1.z.object({
     languageId: zod_1.z.string(),
     templateId: zod_1.z.string(),
     downloadUrl: zod_1.z.string().nullable(),
+    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     userId: zod_1.z.string().uuid().nullable().optional(),
     unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
     slideCount: zod_1.z.number(),

package/build/stt/commands/set-reaction-to-stt-job.command.js

@@ -7,11 +7,21 @@ const common_1 = require("../../common");
 const models_1 = require("../models");
 var SetReactionToSTTJobCommand;
 (function (SetReactionToSTTJobCommand) {
-    SetReactionToSTTJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToSTTJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToSTTJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.STTJobSchema);
 })(SetReactionToSTTJobCommand || (exports.SetReactionToSTTJobCommand = SetReactionToSTTJobCommand = {}));

package/build/stt/models/stt-job.schema.js

@@ -14,6 +14,7 @@ exports.STTJobSchema = zod_1.z.object({
     fileUrl: zod_1.z.string(),
     aiResponse: stt_response_schema_1.STTResponseSchema.nullable(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
     duration: zod_1.z.number(),
     error: zod_1.z.string().nullable(),

package/build/tts/commands/set-reaction-to-tts-job.command.js

@@ -7,11 +7,21 @@ const tts_job_schema_1 = require("../models/tts-job.schema");
 const common_1 = require("../../common");
 var SetReactionToTTSJobCommand;
 (function (SetReactionToTTSJobCommand) {
-    SetReactionToTTSJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToTTSJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToTTSJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(tts_job_schema_1.TTSJobSchema);
 })(SetReactionToTTSJobCommand || (exports.SetReactionToTTSJobCommand = SetReactionToTTSJobCommand = {}));

package/build/tts/models/tts-job.schema.js

@@ -15,6 +15,7 @@ exports.TTSJobSchema = zod_1.z.object({
     userInput: zod_1.z.string(),
     aiResponse: zod_1.z.string().nullable(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     title: zod_1.z.string(),
     status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
     error: zod_1.z.string().nullable(),

package/build/video/commands/set-reaction-to-video-job.command.js

@@ -7,11 +7,21 @@ const video_job_schema_1 = require("../models/video-job.schema");
 const common_1 = require("../../common");
 var SetReactionToVideoJobCommand;
 (function (SetReactionToVideoJobCommand) {
-    SetReactionToVideoJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToVideoJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToVideoJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(video_job_schema_1.VideoJobSchema);
 })(SetReactionToVideoJobCommand || (exports.SetReactionToVideoJobCommand = SetReactionToVideoJobCommand = {}));

package/build/video/models/video-job.schema.js

@@ -15,6 +15,7 @@ exports.VideoJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     prompt: zod_1.z.string(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     externalId: zod_1.z.string().nullable(),
     title: zod_1.z.string(),
     status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),

package/build/video-editor/commands/set-reaction-to-video-editor-job.command.js

@@ -7,11 +7,21 @@ const video_editor_job_schema_1 = require("../models/video-editor-job.schema");
 const common_1 = require("../../common");
 var SetReactionToVideoEditorJobCommand;
 (function (SetReactionToVideoEditorJobCommand) {
-    SetReactionToVideoEditorJobCommand.RequestSchema = zod_1.z.object({
+    SetReactionToVideoEditorJobCommand.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: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToVideoEditorJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(video_editor_job_schema_1.VideoEditorJobSchema);
 })(SetReactionToVideoEditorJobCommand || (exports.SetReactionToVideoEditorJobCommand = SetReactionToVideoEditorJobCommand = {}));

package/build/video-editor/models/video-editor-job.schema.js

@@ -12,6 +12,7 @@ exports.VideoEditorJobSchema = zod_1.z.object({
     error: zod_1.z.string().nullable(),
     price: zod_1.z.number(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     externalId: zod_1.z.string().nullable(),
     modelId: zod_1.z.string(),
     inputVideoUrl: zod_1.z.string(),

package/build/writer/commands/set-reaction-writer-document.command.js

@@ -6,11 +6,21 @@ const common_1 = require("../../common");
 const models_1 = require("../models");
 var SetReactionToWriterDocumentCommand;
 (function (SetReactionToWriterDocumentCommand) {
-    SetReactionToWriterDocumentCommand.RequestSchema = zod_1.z.object({
+    SetReactionToWriterDocumentCommand.RequestSchema = zod_1.z
+        .object({
         userId: zod_1.z.string().uuid().nullable().optional(),
         unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
         documentId: zod_1.z.string().uuid(),
         reaction: zod_1.z.nativeEnum(common_1.USER_REACTION),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
     });
     SetReactionToWriterDocumentCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.WriterDocumentSchema);
 })(SetReactionToWriterDocumentCommand || (exports.SetReactionToWriterDocumentCommand = SetReactionToWriterDocumentCommand = {}));

package/build/writer/models/writer-document.schema.js

@@ -18,6 +18,7 @@ exports.WriterDocumentSchema = zod_1.z.object({
     unregisteredUserId: zod_1.z.string().nullable(),
     modelId: zod_1.z.string().nullable(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
     pages: zod_1.z.number(),
     isDeleted: zod_1.z.boolean(),
     createdAt: zod_1.z.date(),

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

@@ -4,12 +4,25 @@ import { ImageEditorJobSchema } from '../models';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToImageEditorJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(ImageEditorJobSchema);

package/image-editor/models/image-editor-job.schema.ts

@@ -14,6 +14,7 @@ export const ImageEditorJobSchema = z.object({
     uuid: z.string(),
     prompt: z.string(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     title: z.string(),
     status: z.nativeEnum(JOB_STATUS),

package/image-generation/commands/image-generation-model/get-image-generation-model-by-uuid.command.ts

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

package/image-generation/commands/image-generation-model/index.ts

@@ -0,0 +1 @@
+export * from './get-image-generation-model-by-uuid.command';

package/image-generation/commands/index.ts

@@ -5,3 +5,4 @@ export * from './soft-delete-image-generation-job-by-uuid.command';
 export * from './soft-delete-image-generation-jobs-by-criteria.command';
 export * from './set-reaction-to-image-generation-job.command';
 export * from './update-image-generation-job-title.command';
+export * from './image-generation-model';

package/image-generation/commands/set-reaction-to-image-generation-job.command.ts

@@ -4,12 +4,25 @@ import { ICommandResponseSchema } from '../../common/models/command-response.sch
 import { ImageGenerationJobSchema } from '../models';
 
 export namespace SetReactionToImageGenerationJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(ImageGenerationJobSchema);

package/image-generation/enums/image-generation-model-strategy.enum.ts

@@ -21,4 +21,7 @@ export enum IMAGE_GENERATION_MODEL_STRATEGY {
 
     // Flux
     KIE_FLUX_IMAGE_GENERATION = 'KIE_FLUX_IMAGE_GENERATION',
+
+    // Z-Image
+    KIE_Z_IMAGE_GENERATION = 'KIE_Z_IMAGE_GENERATION',
 }

package/image-generation/models/image-generation-job.schema.ts

@@ -19,6 +19,7 @@ export const ImageGenerationJobSchema = z.object({
     error: z.string().nullable(),
     price: z.number(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     params: ImageGenerationJobParamsSchema,
     output: z.array(z.string()),

package/image-generation/routes/image-generation.http.routes.ts

@@ -4,4 +4,5 @@ export const IMAGE_GENERATION_ROUTES = {
     KIE_MIDJOURNEY_CALLBACK: 'kie/midjourney/callback',
     KIE_NANO_BANANA_CALLBACK: 'kie/nano-banana/callback',
     KIE_FLUX_CALLBACK: 'kie/flux/callback',
+    KIE_Z_CALLBACK: 'kie/z-image/callback',
 } as const;

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

@@ -4,12 +4,25 @@ import { MusicJobSchema } from '../models/music-job.schema';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToMusicJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);

package/music/models/music-job.schema.ts

@@ -35,6 +35,7 @@ export const MusicJobSchema = z.object({
     uuid: z.string(),
     prompt: z.string(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     title: z.string(),
     status: z.nativeEnum(JOB_STATUS),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.0.105",
+  "version": "0.0.108",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {

package/paraphrase/commands/set-reaction-to-paraphrase-job.command.ts

@@ -4,12 +4,25 @@ import { ParaphraseJobSchema } from '../models/paraphrase-job.schema';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToParaphraseJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(ParaphraseJobSchema);

package/paraphrase/models/paraphrase-job.schema.ts

@@ -15,6 +15,7 @@ export const ParaphraseJobSchema = z.object({
     title: z.string(),
     error: z.string().nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     typeId: z.string(),
     styleId: z.string(),
     intensity: z.nativeEnum(PARAPHRASING_INTENSITY),

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

@@ -3,12 +3,25 @@ import { ICommandResponseSchema, USER_REACTION } from '../../common';
 import { PresentationSchema } from '../models';
 
 export namespace SetReactionToPresentationCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(PresentationSchema);

package/presentation/models/presentation.schema.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { PRESENTATION_STAGE } from '../enums';
 import { SlideOutlineSchema } from './slide-outline.schema';
 import { SlideSchema } from './slide.schema';
+import { USER_REACTION } from '../../common';
 
 export const PresentationSchema = z.object({
     uuid: z.string().uuid(),
@@ -12,6 +13,8 @@ export const PresentationSchema = z.object({
     languageId: z.string(),
     templateId: z.string(),
     downloadUrl: z.string().nullable(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     userId: z.string().uuid().nullable().optional(),
     unregisteredUserId: z.string().uuid().nullable().optional(),
     slideCount: z.number(),

package/stt/commands/set-reaction-to-stt-job.command.ts

@@ -4,12 +4,25 @@ import { USER_REACTION } from '../../common';
 import { STTJobSchema } from '../models';
 
 export namespace SetReactionToSTTJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(STTJobSchema);

package/stt/models/stt-job.schema.ts

@@ -12,6 +12,7 @@ export const STTJobSchema = z.object({
     fileUrl: z.string(),
     aiResponse: STTResponseSchema.nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     status: z.nativeEnum(JOB_STATUS),
     duration: z.number(),
     error: z.string().nullable(),

package/tts/commands/set-reaction-to-tts-job.command.ts

@@ -4,12 +4,25 @@ import { TTSJobSchema } from '../models/tts-job.schema';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToTTSJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(TTSJobSchema);

package/tts/models/tts-job.schema.ts

@@ -15,6 +15,7 @@ export const TTSJobSchema = z.object({
     userInput: z.string(),
     aiResponse: z.string().nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     title: z.string(),
     status: z.nativeEnum(JOB_STATUS),
     error: z.string().nullable(),

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

@@ -4,12 +4,25 @@ import { VideoJobSchema } from '../models/video-job.schema';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToVideoJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(VideoJobSchema);

package/video/models/video-job.schema.ts

@@ -16,6 +16,7 @@ export const VideoJobSchema = z.object({
     uuid: z.string(),
     prompt: z.string(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     title: z.string(),
     status: z.nativeEnum(JOB_STATUS),

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

@@ -4,12 +4,25 @@ import { VideoEditorJobSchema } from '../models/video-editor-job.schema';
 import { USER_REACTION } from '../../common';
 
 export namespace SetReactionToVideoEditorJobCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        uuid: z.string(),
-        reaction: z.nativeEnum(USER_REACTION).nullable(),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            uuid: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION).nullable(),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(VideoEditorJobSchema);

package/video-editor/models/video-editor-job.schema.ts

@@ -10,6 +10,7 @@ export const VideoEditorJobSchema = z.object({
     error: z.string().nullable(),
     price: z.number(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     externalId: z.string().nullable(),
     modelId: z.string(),
     inputVideoUrl: z.string(),

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

@@ -3,12 +3,25 @@ import { ICommandResponseSchema, USER_REACTION } from '../../common';
 import { WriterDocumentSchema } from '../models';
 
 export namespace SetReactionToWriterDocumentCommand {
-    export const RequestSchema = z.object({
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        documentId: z.string().uuid(),
-        reaction: z.nativeEnum(USER_REACTION),
-    });
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().nullable().optional(),
+            unregisteredUserId: z.string().uuid().nullable().optional(),
+            documentId: z.string().uuid(),
+            reaction: z.nativeEnum(USER_REACTION),
+            dislikeReason: z.string().nullable().default(null),
+        })
+        .refine(
+            (data) => {
+                if (data.reaction !== USER_REACTION.DISLIKED && data.dislikeReason) {
+                    return false;
+                }
+                return true;
+            },
+            {
+                message: 'Dislike reason is not allowed when reaction is not disliked',
+            },
+        );
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = ICommandResponseSchema(WriterDocumentSchema);

package/writer/models/writer-document.schema.ts

@@ -16,6 +16,7 @@ export const WriterDocumentSchema = z.object({
     unregisteredUserId: z.string().nullable(),
     modelId: z.string().nullable(),
     reaction: z.nativeEnum(USER_REACTION).nullable(),
+    dislikeReason: z.string().nullable(),
     pages: z.number(),
     isDeleted: z.boolean(),
     createdAt: z.date(),