@purpleschool/gptbot-tools 0.0.59 → 0.0.61

package/build/music/queries/get-music-config.query.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMusicConfigQuery = void 0;
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var GetMusicConfigQuery;
+(function (GetMusicConfigQuery) {
+    GetMusicConfigQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.MusicConfigSchema);
+})(GetMusicConfigQuery || (exports.GetMusicConfigQuery = GetMusicConfigQuery = {}));

package/build/music/queries/index.js

@@ -0,0 +1,19 @@
+"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("./find-music-job-by-id.query"), exports);
+__exportStar(require("./find-music-jobs.query"), exports);
+__exportStar(require("./get-music-config.query"), exports);

package/build/music/routes/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("./music.amqp.routes"), exports);

package/build/music/routes/music.amqp.routes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MUSIC_AMQP_ROUTES = void 0;
+exports.MUSIC_AMQP_ROUTES = {
+    EXECUTE: 'tools.music.execute.rpc',
+    GENERATE_LYRICS: 'tools.music.generate-lyrics.rpc',
+    CONVERT_TO_WAV: 'tools.music.convert-to-wav.rpc',
+    CONFIG: 'tools.music.config.rpc',
+    GET_JOB: 'tools.music.jobs.get.rpc',
+    LIST_JOBS: 'tools.music.jobs.list.rpc',
+    SET_REACTION: 'tools.music.jobs.set-reaction.rpc',
+    UPDATE_TITLE: 'tools.music.jobs.update-title.rpc',
+    SOFT_DELETE: 'tools.music.jobs.soft-delete.rpc',
+    SOFT_DELETE_ALL: 'tools.music.jobs.soft-delete-all.rpc',
+    RETRY: 'tools.music.jobs.retry.rpc',
+};

package/build/music/utils/calculate-music-generation-price.util.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateMusicGenerationPrice = calculateMusicGenerationPrice;
+function calculateMusicGenerationPrice({ pricePerTrack }) {
+    const base = pricePerTrack;
+    return Math.ceil(base);
+}

package/build/music/utils/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("./calculate-music-generation-price.util"), exports);

package/build/tools/enums/tool-type.enum.js

@@ -12,4 +12,6 @@ var TOOL_TYPE;
     TOOL_TYPE["PARAPHRASE"] = "PARAPHRASE";
     TOOL_TYPE["WRITER_ACTION"] = "WRITER_ACTION";
     TOOL_TYPE["VIDEO_EDITOR"] = "VIDEO_EDITOR";
+    TOOL_TYPE["MUSIC"] = "MUSIC";
+    TOOL_TYPE["MUSIC_ACTION"] = "MUSIC_ACTION";
 })(TOOL_TYPE || (exports.TOOL_TYPE = TOOL_TYPE = {}));

package/build/writer/commands/create-writer-document.command.js

@@ -12,7 +12,6 @@ var CreateWriterDocumentCommand;
         prompt: zod_1.z.string(),
         numPages: zod_1.z.number(),
         documentTypeId: zod_1.z.string().uuid(),
-        modelId: zod_1.z.string().uuid(),
     });
     CreateWriterDocumentCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.WriterDocumentSchema);
 })(CreateWriterDocumentCommand || (exports.CreateWriterDocumentCommand = CreateWriterDocumentCommand = {}));

package/build/writer/commands/generate-document-contents.command.js

@@ -11,6 +11,7 @@ var GenerateWriterDocumentContentsCommand;
         userId: zod_1.z.string().uuid().nullable().optional(),
         unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
         userBalance: zod_1.z.number(),
+        modelId: zod_1.z.string(),
     });
     GenerateWriterDocumentContentsCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.WriterDocumentSchema);
 })(GenerateWriterDocumentContentsCommand || (exports.GenerateWriterDocumentContentsCommand = GenerateWriterDocumentContentsCommand = {}));

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

@@ -16,7 +16,7 @@ exports.WriterDocumentSchema = zod_1.z.object({
     finalMd: zod_1.z.string().nullable(),
     userId: zod_1.z.string().nullable(),
     unregisteredUserId: zod_1.z.string().nullable(),
-    modelId: zod_1.z.string(),
+    modelId: zod_1.z.string().nullable(),
     reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
     pages: zod_1.z.number(),
     isDeleted: zod_1.z.boolean(),

package/common/errors/errors.ts

@@ -877,4 +877,171 @@ export const ERRORS = {
             httpCode: 500,
         },
     },
+    MUSIC_EDITOR: {
+        AI_ERROR: {
+            code: 'MUSIC_EDITOR.AI_ERROR',
+            message: 'Произошла ошибка во время запроса к ИИ',
+            httpCode: 500,
+        },
+        INSUFFICIENT_BALANCE: {
+            code: 'MUSIC_EDITOR.INSUFFICIENT_BALANCE',
+            message: 'У пользователя недостаточно средств',
+            httpCode: 400,
+        },
+        DELETE_ERROR: {
+            code: 'MUSIC_EDITOR.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении',
+            httpCode: 500,
+        },
+        MAX_PROMPT_LENGTH_EXCEEDED: {
+            code: 'MUSIC_EDITOR.MAX_PROMPT_LENGTH_EXCEEDED',
+            message: 'Превышена максимальная длина запроса',
+            httpCode: 400,
+        },
+        MAX_DURATION_EXCEEDED: {
+            code: 'MUSIC_EDITOR.MAX_DURATION_EXCEEDED',
+            message: 'Превышена максимальная длительность музыки',
+            httpCode: 400,
+        },
+    },
+    MUSIC_EDITOR_JOB: {
+        SAVE_ERROR: {
+            code: 'MUSIC_EDITOR_JOB.SAVE_ERROR',
+            message: 'Произошла ошибка при сохранении задания на редактирование музыки',
+            httpCode: 500,
+        },
+        FIND_ERROR: {
+            code: 'MUSIC_EDITOR_JOB.FIND_ERROR',
+            message: 'Произошла ошибка при поиске задания на редактирование музыки',
+            httpCode: 500,
+        },
+        NOT_FOUND: {
+            code: 'MUSIC_EDITOR_JOB.NOT_FOUND',
+            message: 'Задание на редактирование музыки не найдено',
+            httpCode: 404,
+        },
+        NOT_AN_OWNER: {
+            code: 'MUSIC_EDITOR_JOB.NOT_AN_OWNER',
+            message: 'Пользователь не является владельцем задания на редактирование музыки',
+            httpCode: 403,
+        },
+        NOT_IN_FAILED_STATE_TO_RETRY: {
+            code: 'MUSIC_EDITOR_JOB.NOT_IN_FAILED_STATE_TO_RETRY',
+            message:
+                'Задание на редактирование музыки не в состоянии "failed". Невозможно повторить',
+            httpCode: 400,
+        },
+        DELETE_ERROR: {
+            code: 'MUSIC_EDITOR_JOB.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении задания на редактирование музыки',
+            httpCode: 500,
+        },
+    },
+    MUSIC: {
+        AI_ERROR: {
+            code: 'MUSIC.AI_ERROR',
+            message: 'Произошла ошибка во время запроса к ИИ',
+            httpCode: 500,
+        },
+        INSUFFICIENT_BALANCE: {
+            code: 'MUSIC.INSUFFICIENT_BALANCE',
+            message: 'У пользователя недостаточно средств',
+            httpCode: 400,
+        },
+        INVALID_PARAMS: {
+            code: 'MUSIC.INVALID_PARAMS',
+            message: 'Некорректные параметры музыки',
+            httpCode: 400,
+        },
+        DELETE_ERROR: {
+            code: 'MUSIC.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении генерации музыки',
+            httpCode: 500,
+        },
+        INVALID_GENDER: {
+            code: 'MUSIC.INVALID_GENDER',
+            message: 'Некорректный выбор голоса вокала',
+            httpCode: 400,
+        },
+        MAX_PROMPT_LENGTH_EXCEEDED: {
+            code: 'MUSIC.MAX_PROMPT_LENGTH_EXCEEDED',
+            message: 'Превышена максимальная длина запроса',
+            httpCode: 400,
+        },
+        SUNO_CONTENT_POLICY: {
+            code: 'MUSIC.SUNO_CONTENT_POLICY',
+            message:
+                'Запрос на создание музыки был отклонен, т.к. он не соответствует требованиям политики безопасности Suno.',
+            httpCode: 400,
+        },
+        GENERATE_LYRICS_ERROR: {
+            code: 'MUSIC.GENERATE_LYRICS_ERROR',
+            message: 'Произошла ошибка при генерации текста музыки',
+            httpCode: 500,
+        },
+        CONVERT_TO_WAV_ERROR: {
+            code: 'MUSIC.CONVERT_TO_WAV_ERROR',
+            message: 'Произошла ошибка при конвертации mp3 в wav',
+            httpCode: 500,
+        },
+        POLL_TIMEOUT: {
+            code: 'MUSIC.POLL_TIMEOUT',
+            message: 'Превышено время ожидания генерации музыки',
+            httpCode: 500,
+        },
+    },
+    MUSIC_MODEL: {
+        SAVE_ERROR: {
+            code: 'MUSIC_MODEL.SAVE_ERROR',
+            message: 'Произошла ошибка при сохранении модели для генерации музыки',
+            httpCode: 500,
+        },
+        FIND_ERROR: {
+            code: 'MUSIC_MODEL.FIND_ERROR',
+            message: 'Произошла ошибка при поиске модели для генерации музыки',
+            httpCode: 500,
+        },
+        NOT_FOUND: {
+            code: 'MUSIC_MODEL.NOT_FOUND',
+            message: 'Модель для генерации музыки не найдена',
+            httpCode: 404,
+        },
+        MODEL_ARCHIVED: {
+            code: 'MUSIC_MODEL.MODEL_ARCHIVED',
+            message: 'Модель для генерации музыки архивирована',
+            httpCode: 400,
+        },
+    },
+    MUSIC_JOB: {
+        SAVE_ERROR: {
+            code: 'MUSIC_JOB.SAVE_ERROR',
+            message: 'Произошла ошибка при сохранении задания на генерацию музыки',
+            httpCode: 500,
+        },
+        FIND_ERROR: {
+            code: 'MUSIC_JOB.FIND_ERROR',
+            message: 'Произошла ошибка при поиске задания на генерацию музыки',
+            httpCode: 500,
+        },
+        NOT_FOUND: {
+            code: 'MUSIC_JOB.NOT_FOUND',
+            message: 'Задание на генерацию музыки не найдено',
+            httpCode: 404,
+        },
+        NOT_AN_OWNER: {
+            code: 'MUSIC_JOB.NOT_AN_OWNER',
+            message: 'Пользователь не является владельцем задания на генерацию музыки',
+            httpCode: 403,
+        },
+        NOT_IN_FAILED_STATE_TO_RETRY: {
+            code: 'MUSIC_JOB.NOT_IN_FAILED_STATE_TO_RETRY',
+            message: 'Задание на генерацию музыки не в состоянии "failed". Невозможно повторить',
+            httpCode: 400,
+        },
+        DELETE_ERROR: {
+            code: 'MUSIC_JOB.DELETE_ERROR',
+            message: 'Произошла ошибка при удалении задания на генерацию музыки',
+            httpCode: 500,
+        },
+    },
 } as const;

package/index.ts

@@ -8,6 +8,7 @@ export * from './video';
 export * from './writer';
 export * from './image-editor';
 export * from './video-editor';
+export * from './music';
 
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -20,6 +21,7 @@ import * as video from './video';
 import * as writer from './writer';
 import * as imageEditor from './image-editor';
 import * as videoEditor from './video-editor';
+import * as music from './music';
 
 export namespace ToolService {
     export import Common = common;
@@ -33,4 +35,5 @@ export namespace ToolService {
     export import Writer = writer;
     export import ImageEditor = imageEditor;
     export import VideoEditor = videoEditor;
+    export import Music = music;
 }

package/music/commands/convert-to-wav.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace ConvertToWavCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        taskId: z.string(),
+        audioId: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.object({ url: z.string().url() }));
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/delete-all-music-jobs.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteAllMusicJobsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/delete-music-job-by-uuid.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteMusicJobByUuidCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        uuid: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace GenerateLyricsCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
+        prompt: z.string(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            title: z.string(),
+            lyrics: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicJobSchema } from '../models/music-job.schema';
+import { MusicJobParamsSchema } from '../models';
+
+export namespace GenerateMusicCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
+        modelId: z.string(),
+        params: MusicJobParamsSchema,
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/index.ts

@@ -0,0 +1,8 @@
+export * from './delete-music-job-by-uuid.command';
+export * from './delete-all-music-jobs.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/music/commands/retry-music-job.command.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicJobSchema } from '../models/music-job.schema';
+
+export namespace RetryMusicJobCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userBalance: z.number(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+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 type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicJobSchema } from '../models/music-job.schema';
+
+export namespace UpdateMusicJobTitleCommand {
+    export const RequestSchema = z.object({
+        uuid: z.string().uuid(),
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        title: z.string().min(1).max(40),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/enums/index.ts

@@ -0,0 +1,6 @@
+export * from './suno-model-type.enum';
+export * from './music-strategy.enum';
+export * from './music-vocal-gender.enum';
+export * from './music-pricing-rule-type.enum';
+export * from './suno-mode-type.enum';
+export * from './music-action-type.enum';

package/music/enums/music-action-type.enum.ts

@@ -0,0 +1,3 @@
+export enum MUSIC_ACTION_TYPE {
+    LYRICS = 'LYRICS',
+}

package/music/enums/music-pricing-rule-type.enum.ts

@@ -0,0 +1,3 @@
+export enum MUSIC_PRICING_RULE_TYPE {
+    FLAT = 'flat',
+}

package/music/enums/music-strategy.enum.ts

@@ -0,0 +1,3 @@
+export enum MUSIC_GENERATION_STRATEGY {
+    SUNO_POLLING = 'SUNO_POLLING',
+}

package/music/enums/music-vocal-gender.enum.ts

@@ -0,0 +1,4 @@
+export enum MUSIC_VOCAL_GENDER {
+    MALE = 'm',
+    FEMALE = 'f',
+}

package/music/enums/suno-mode-type.enum.ts

@@ -0,0 +1,6 @@
+export enum SUNO_MODE_TYPE {
+    SIMPLE = 'simple',
+    SIMPLE_INSTRUMENTAL = 'simple_instrumental',
+    CUSTOM = 'custom',
+    CUSTOM_INSTRUMENTAL = 'custom_instrumental',
+}

package/music/enums/suno-model-type.enum.ts

@@ -0,0 +1,6 @@
+export enum SUNO_MODEL_TYPE {
+    V4 = 'V4',
+    V4_5 = 'V4_5',
+    V4_5PLUS = 'V4_5PLUS',
+    V5 = 'V5',
+}

package/music/index.ts

@@ -0,0 +1,6 @@
+export * from './commands';
+export * from './enums';
+export * from './models';
+export * from './queries';
+export * from './routes';
+export * from './utils';

package/music/models/index.ts

@@ -0,0 +1,4 @@
+export * from './music-config.schema';
+export * from './music-job.schema';
+export * from './music-model.schema';
+export * from './music-track.schema';

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { MusicModelSchema } from './music-model.schema';
+
+export const MusicConfigSchema = z.object({
+    models: z.array(MusicModelSchema),
+});
+
+export type MusicConfig = z.infer<typeof MusicConfigSchema>;

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { JOB_STATUS } from '../../tools';
+import { USER_REACTION } from '../../common';
+import { MUSIC_VOCAL_GENDER } from '../enums';
+import { MusicTrackSchema } from './music-track.schema';
+import { SUNO_MODE_TYPE } from '../enums/suno-mode-type.enum';
+
+export const MusicJobParamsSchema = z.discriminatedUnion('mode', [
+    z.object({
+        mode: z.literal(SUNO_MODE_TYPE.SIMPLE),
+        prompt: z.string().min(1).max(450),
+        style: z.string(),
+        vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER),
+    }),
+    z.object({
+        mode: z.literal(SUNO_MODE_TYPE.SIMPLE_INSTRUMENTAL),
+        prompt: z.string().min(1).max(450),
+        style: z.string(),
+    }),
+    z.object({
+        mode: z.literal(SUNO_MODE_TYPE.CUSTOM),
+        prompt: z.string().min(1).max(5000),
+        title: z.string().min(1).max(80),
+        style: z.string().min(1).max(1000),
+        vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER),
+    }),
+    z.object({
+        mode: z.literal(SUNO_MODE_TYPE.CUSTOM_INSTRUMENTAL),
+        title: z.string().min(1).max(80),
+        style: z.string().min(1).max(1000),
+    }),
+]);
+
+export type MusicJobParams = z.infer<typeof MusicJobParamsSchema>;
+
+export const MusicJobSchema = z.object({
+    uuid: z.string(),
+    prompt: z.string(),
+    reaction: z.nativeEnum(USER_REACTION).nullable(),
+    externalId: z.string().nullable(),
+    title: z.string(),
+    status: z.nativeEnum(JOB_STATUS),
+    error: z.string().nullable(),
+    modelId: z.string(),
+    price: z.number(),
+    params: MusicJobParamsSchema,
+    tracks: z.array(MusicTrackSchema),
+    attempts: z.array(z.any()),
+    userId: z.string().nullable().optional(),
+    unregisteredUserId: z.string().nullable().optional(),
+    isDeleted: z.boolean(),
+    createdAt: z.date(),
+    completedAt: z.date().nullable().optional(),
+    updatedAt: z.date(),
+});
+
+export type MusicJob = z.infer<typeof MusicJobSchema>;

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { TOOL_MODEL_STATUS, IconVariantsSchema } from '../../common';
+import { MUSIC_GENERATION_STRATEGY, MUSIC_VOCAL_GENDER } from '../enums';
+import { SUNO_MODEL_TYPE } from '../enums';
+
+export const MusicModelParamsSchema = z.object({
+    vocalGender: z.object({
+        options: z.array(z.nativeEnum(MUSIC_VOCAL_GENDER)),
+    }),
+    styles: z.object({
+        maxStyles: z.number(),
+        options: z.array(
+            z.object({
+                title: z.string(),
+                style: z.string(),
+            }),
+        ),
+    }),
+});
+
+export type MusicModelParams = z.infer<typeof MusicModelParamsSchema>;
+
+export const MusicModelSchema = z.object({
+    uuid: z.string(),
+    title: z.string(),
+    description: z.string(),
+    aiModel: z.nativeEnum(SUNO_MODEL_TYPE),
+    pricePerTrack: z.number(),
+    order: z.number(),
+    status: z.nativeEnum(TOOL_MODEL_STATUS),
+    icons: IconVariantsSchema,
+    strategy: z.nativeEnum(MUSIC_GENERATION_STRATEGY),
+    maxPromptLength: z.number(),
+    maxLyricsLength: z.number(),
+    params: MusicModelParamsSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type MusicModel = z.infer<typeof MusicModelSchema>;