@purpleschool/gptbot-tools 0.2.48 → 0.2.50

package/build/music/commands/add-track-to-music-playlist.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddTrackToMusicPlaylistCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const music_playlist_schema_1 = require("../models/music-playlist.schema");
+var AddTrackToMusicPlaylistCommand;
+(function (AddTrackToMusicPlaylistCommand) {
+    AddTrackToMusicPlaylistCommand.RequestSchema = zod_1.z
+        .object({
+        playlistId: zod_1.z.string().uuid(),
+        trackId: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'At least userId or unregisteredUserId must be present',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    AddTrackToMusicPlaylistCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(music_playlist_schema_1.MusicPlaylistSchema);
+})(AddTrackToMusicPlaylistCommand || (exports.AddTrackToMusicPlaylistCommand = AddTrackToMusicPlaylistCommand = {}));

package/build/music/commands/boost-music-style.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoostMusicStyleCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var BoostMusicStyleCommand;
+(function (BoostMusicStyleCommand) {
+    BoostMusicStyleCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        userBalance: zod_1.z.number(),
+        content: zod_1.z.string().min(1).max(3000),
+    });
+    BoostMusicStyleCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.object({
+        result: zod_1.z.string(),
+    }));
+})(BoostMusicStyleCommand || (exports.BoostMusicStyleCommand = BoostMusicStyleCommand = {}));

package/build/music/commands/create-music-playlist.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateMusicPlaylistCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const music_playlist_schema_1 = require("../models/music-playlist.schema");
+var CreateMusicPlaylistCommand;
+(function (CreateMusicPlaylistCommand) {
+    CreateMusicPlaylistCommand.RequestSchema = zod_1.z
+        .object({
+        title: zod_1.z.string().min(1).max(80).trim(),
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'At least userId or unregisteredUserId must be present',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    CreateMusicPlaylistCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(music_playlist_schema_1.MusicPlaylistSchema);
+})(CreateMusicPlaylistCommand || (exports.CreateMusicPlaylistCommand = CreateMusicPlaylistCommand = {}));

package/build/music/commands/delete-music-playlist.command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteMusicPlaylistCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var DeleteMusicPlaylistCommand;
+(function (DeleteMusicPlaylistCommand) {
+    DeleteMusicPlaylistCommand.RequestSchema = zod_1.z
+        .object({
+        uuid: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'At least userId or unregisteredUserId must be present',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    DeleteMusicPlaylistCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(DeleteMusicPlaylistCommand || (exports.DeleteMusicPlaylistCommand = DeleteMusicPlaylistCommand = {}));

package/build/music/commands/edit-music.command.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditMusicCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var EditMusicCommand;
+(function (EditMusicCommand) {
+    EditMusicCommand.RequestSchema = models_1.MusicEditRequestSchema;
+    EditMusicCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.union([models_1.MusicJobSchema, models_1.MusicEditActionResultSchema]));
+})(EditMusicCommand || (exports.EditMusicCommand = EditMusicCommand = {}));

package/build/music/commands/generate-music.command.js

@@ -6,12 +6,17 @@ const command_response_schema_1 = require("../../common/models/command-response.
 const locale_schema_1 = require("../../common/models/locale.schema");
 const music_job_schema_1 = require("../models/music-job.schema");
 const models_1 = require("../models");
+const enums_1 = require("../enums");
 var GenerateMusicCommand;
 (function (GenerateMusicCommand) {
     GenerateMusicCommand.RequestSchema = zod_1.z.object({
         locale: locale_schema_1.LocaleSchema,
         userId: zod_1.z.string().uuid().nullable().optional(),
         unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        actionType: zod_1.z
+            .nativeEnum(enums_1.MUSIC_GENERATION_ACTION_TYPE)
+            .optional()
+            .default(enums_1.MUSIC_GENERATION_ACTION_TYPE.GENERATE),
         modelId: zod_1.z.string(),
         params: models_1.MusicJobParamsSchema,
         tokenReservationId: zod_1.z.string().uuid(),

package/build/music/commands/index.js

@@ -14,15 +14,22 @@ 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("./add-track-to-music-playlist.command"), exports);
+__exportStar(require("./create-music-playlist.command"), exports);
+__exportStar(require("./delete-music-playlist.command"), exports);
+__exportStar(require("./edit-music.command"), exports);
 __exportStar(require("./delete-music-job-by-uuid.command"), exports);
 __exportStar(require("./delete-all-music-jobs.command"), exports);
+__exportStar(require("./remove-track-from-music-playlist.command"), exports);
 __exportStar(require("./retry-music-job.command"), exports);
 __exportStar(require("./set-reaction-to-music-job.command"), exports);
 __exportStar(require("./generate-music.command"), exports);
 __exportStar(require("./get-music-price.command"), exports);
 __exportStar(require("./update-music-job-title.command"), exports);
 __exportStar(require("./update-music-job-favorite.command"), exports);
+__exportStar(require("./update-music-playlist.command"), exports);
 __exportStar(require("./convert-to-wav.command"), exports);
 __exportStar(require("./generate-lyrics.command"), exports);
+__exportStar(require("./boost-music-style.command"), exports);
 __exportStar(require("./music-model"), exports);
 __exportStar(require("./update-published-status-music-jobs.command"), exports);

package/build/music/commands/remove-track-from-music-playlist.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveTrackFromMusicPlaylistCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const music_playlist_schema_1 = require("../models/music-playlist.schema");
+var RemoveTrackFromMusicPlaylistCommand;
+(function (RemoveTrackFromMusicPlaylistCommand) {
+    RemoveTrackFromMusicPlaylistCommand.RequestSchema = zod_1.z
+        .object({
+        playlistId: zod_1.z.string().uuid(),
+        trackId: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'At least userId or unregisteredUserId must be present',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    RemoveTrackFromMusicPlaylistCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(music_playlist_schema_1.MusicPlaylistSchema);
+})(RemoveTrackFromMusicPlaylistCommand || (exports.RemoveTrackFromMusicPlaylistCommand = RemoveTrackFromMusicPlaylistCommand = {}));

package/build/music/commands/update-music-playlist.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateMusicPlaylistCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const music_playlist_schema_1 = require("../models/music-playlist.schema");
+var UpdateMusicPlaylistCommand;
+(function (UpdateMusicPlaylistCommand) {
+    UpdateMusicPlaylistCommand.RequestSchema = zod_1.z
+        .object({
+        uuid: zod_1.z.string().uuid(),
+        title: zod_1.z.string().min(1).max(80).trim(),
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'At least userId or unregisteredUserId must be present',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    UpdateMusicPlaylistCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(music_playlist_schema_1.MusicPlaylistSchema);
+})(UpdateMusicPlaylistCommand || (exports.UpdateMusicPlaylistCommand = UpdateMusicPlaylistCommand = {}));

package/build/music/enums/index.js

@@ -20,3 +20,6 @@ __exportStar(require("./music-vocal-gender.enum"), exports);
 __exportStar(require("./music-pricing-rule-type.enum"), exports);
 __exportStar(require("./suno-mode-type.enum"), exports);
 __exportStar(require("./music-action-type.enum"), exports);
+__exportStar(require("./music-audio-action-type.enum"), exports);
+__exportStar(require("./music-generation-action-type.enum"), exports);
+__exportStar(require("./music-lyrics-structure.enum"), exports);

package/build/music/enums/music-action-type.enum.js

@@ -4,4 +4,11 @@ exports.MUSIC_ACTION_TYPE = void 0;
 var MUSIC_ACTION_TYPE;
 (function (MUSIC_ACTION_TYPE) {
     MUSIC_ACTION_TYPE["LYRICS"] = "LYRICS";
+    MUSIC_ACTION_TYPE["BOOST_STYLE"] = "BOOST_STYLE";
+    MUSIC_ACTION_TYPE["REMOVE_VOCALS"] = "REMOVE_VOCALS";
+    MUSIC_ACTION_TYPE["EXTRACT_VOCALS"] = "EXTRACT_VOCALS";
+    MUSIC_ACTION_TYPE["COVER"] = "COVER";
+    MUSIC_ACTION_TYPE["EXTEND"] = "EXTEND";
+    MUSIC_ACTION_TYPE["ADD_INSTRUMENTAL"] = "ADD_INSTRUMENTAL";
+    MUSIC_ACTION_TYPE["ADD_VOCALS"] = "ADD_VOCALS";
 })(MUSIC_ACTION_TYPE || (exports.MUSIC_ACTION_TYPE = MUSIC_ACTION_TYPE = {}));

package/build/music/enums/music-audio-action-type.enum.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MUSIC_AUDIO_ACTION_TYPE = void 0;
+var MUSIC_AUDIO_ACTION_TYPE;
+(function (MUSIC_AUDIO_ACTION_TYPE) {
+    MUSIC_AUDIO_ACTION_TYPE["REMOVE_VOCALS"] = "removeVocals";
+    MUSIC_AUDIO_ACTION_TYPE["EXTRACT_VOCALS"] = "extractVocals";
+    MUSIC_AUDIO_ACTION_TYPE["COVER"] = "cover";
+    MUSIC_AUDIO_ACTION_TYPE["EXTEND"] = "extend";
+    MUSIC_AUDIO_ACTION_TYPE["ADD_INSTRUMENTAL"] = "addInstrumental";
+    MUSIC_AUDIO_ACTION_TYPE["ADD_VOCALS"] = "addVocals";
+})(MUSIC_AUDIO_ACTION_TYPE || (exports.MUSIC_AUDIO_ACTION_TYPE = MUSIC_AUDIO_ACTION_TYPE = {}));

package/build/music/enums/music-generation-action-type.enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MUSIC_GENERATION_ACTION_TYPE = void 0;
+var MUSIC_GENERATION_ACTION_TYPE;
+(function (MUSIC_GENERATION_ACTION_TYPE) {
+    MUSIC_GENERATION_ACTION_TYPE["GENERATE"] = "generate";
+    MUSIC_GENERATION_ACTION_TYPE["GIFT"] = "gift";
+    MUSIC_GENERATION_ACTION_TYPE["BACKGROUND"] = "background";
+    MUSIC_GENERATION_ACTION_TYPE["GENERATE_LYRICS"] = "generateLyrics";
+})(MUSIC_GENERATION_ACTION_TYPE || (exports.MUSIC_GENERATION_ACTION_TYPE = MUSIC_GENERATION_ACTION_TYPE = {}));

package/build/music/enums/music-lyrics-structure.enum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MUSIC_LYRICS_STRUCTURE = void 0;
+var MUSIC_LYRICS_STRUCTURE;
+(function (MUSIC_LYRICS_STRUCTURE) {
+    MUSIC_LYRICS_STRUCTURE["VERSE_CHORUS"] = "verse_chorus";
+    MUSIC_LYRICS_STRUCTURE["WITH_BRIDGE"] = "with_bridge";
+    MUSIC_LYRICS_STRUCTURE["FREE"] = "free";
+})(MUSIC_LYRICS_STRUCTURE || (exports.MUSIC_LYRICS_STRUCTURE = MUSIC_LYRICS_STRUCTURE = {}));

package/build/music/models/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./music-config-with-vendors.schema"), exports);
 __exportStar(require("./music-job.schema"), exports);
 __exportStar(require("./music-model.schema"), exports);
 __exportStar(require("./music-model-with-vendor.schema"), exports);
+__exportStar(require("./music-playlist.schema"), exports);
 __exportStar(require("./music-track.schema"), exports);

package/build/music/models/music-config-with-vendors.schema.js

@@ -4,7 +4,9 @@ exports.MusicConfigWithVendorsSchema = void 0;
 const zod_1 = require("zod");
 const ai_vendor_1 = require("../../ai-vendor");
 const music_model_with_vendor_schema_1 = require("./music-model-with-vendor.schema");
+const music_config_schema_1 = require("./music-config.schema");
 exports.MusicConfigWithVendorsSchema = zod_1.z.object({
     vendors: zod_1.z.array(ai_vendor_1.AiVendorSchema),
     models: zod_1.z.array(music_model_with_vendor_schema_1.MusicModelWithVendorSchema),
+    audioActionPrices: music_config_schema_1.MusicAudioActionPricesSchema,
 });

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

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MusicConfigSchema = void 0;
+exports.MusicConfigSchema = exports.MusicAudioActionPricesSchema = void 0;
 const zod_1 = require("zod");
 const music_model_schema_1 = require("./music-model.schema");
+const enums_1 = require("../enums");
+exports.MusicAudioActionPricesSchema = zod_1.z.record(zod_1.z.nativeEnum(enums_1.MUSIC_AUDIO_ACTION_TYPE), zod_1.z.number());
 exports.MusicConfigSchema = zod_1.z.object({
     models: zod_1.z.array(music_model_schema_1.MusicModelSchema),
+    audioActionPrices: exports.MusicAudioActionPricesSchema,
 });

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MusicJobSchema = exports.MusicJobParamsSchema = void 0;
+exports.MusicJobSchema = exports.MusicExecuteRequestSchema = exports.MusicAnyJobParamsSchema = exports.MusicEditActionResultSchema = exports.MusicEditRequestSchema = exports.MusicAddVocalsParamsSchema = exports.MusicAddInstrumentalParamsSchema = exports.MusicUploadExtendParamsSchema = exports.MusicUploadCoverParamsSchema = exports.MusicSeparateVocalsParamsSchema = exports.MusicBackgroundParamsSchema = exports.MusicLyricsParamsSchema = exports.MusicJobParamsSchema = void 0;
 const zod_1 = require("zod");
 const tools_1 = require("../../tools");
 const common_1 = require("../../common");
@@ -30,6 +30,137 @@ exports.MusicJobParamsSchema = zod_1.z.discriminatedUnion('mode', [
         style: zod_1.z.string().min(1).max(1000),
     }),
 ]);
+exports.MusicLyricsParamsSchema = zod_1.z.object({
+    prompt: zod_1.z.string().min(1).max(1000),
+    style: zod_1.z.string().min(1).max(200).optional(),
+    structure: zod_1.z.nativeEnum(enums_1.MUSIC_LYRICS_STRUCTURE),
+});
+exports.MusicBackgroundParamsSchema = zod_1.z.object({
+    prompt: zod_1.z.string().min(1).max(450),
+    style: zod_1.z.string(),
+});
+exports.MusicSeparateVocalsParamsSchema = zod_1.z.object({
+    externalId: zod_1.z.string().uuid(),
+    audioId: zod_1.z.string().min(1),
+});
+exports.MusicUploadCoverParamsSchema = zod_1.z.object({
+    audioId: zod_1.z.string().uuid(),
+    uploadUrl: zod_1.z.string().url(),
+    style: zod_1.z.string().min(1).max(1000),
+    prompt: zod_1.z.string().min(1).max(5000).optional(),
+    title: zod_1.z.string().min(1).max(80).optional(),
+    negativeTags: zod_1.z.string().max(1000).optional(),
+    vocalGender: zod_1.z.nativeEnum(enums_1.MUSIC_VOCAL_GENDER).optional(),
+    instrumental: zod_1.z.boolean().optional(),
+});
+exports.MusicUploadExtendParamsSchema = zod_1.z.object({
+    audioId: zod_1.z.string().uuid(),
+    uploadUrl: zod_1.z.string().url(),
+    continueAt: zod_1.z.number().positive(),
+    prompt: zod_1.z.string().min(1).max(5000),
+    style: zod_1.z.string().min(1).max(1000).optional(),
+    title: zod_1.z.string().min(1).max(80).optional(),
+    negativeTags: zod_1.z.string().max(1000).optional(),
+    vocalGender: zod_1.z.nativeEnum(enums_1.MUSIC_VOCAL_GENDER).optional(),
+    instrumental: zod_1.z.boolean().optional(),
+});
+exports.MusicAddInstrumentalParamsSchema = zod_1.z.object({
+    audioId: zod_1.z.string().uuid(),
+    uploadUrl: zod_1.z.string().url(),
+    style: zod_1.z.string().min(1).max(1000),
+    title: zod_1.z.string().min(1).max(80).optional(),
+    negativeTags: zod_1.z.string().max(1000).optional(),
+    vocalGender: zod_1.z.nativeEnum(enums_1.MUSIC_VOCAL_GENDER).optional(),
+});
+exports.MusicAddVocalsParamsSchema = zod_1.z.object({
+    audioId: zod_1.z.string().uuid(),
+    uploadUrl: zod_1.z.string().url(),
+    prompt: zod_1.z.string().min(1).max(5000),
+    style: zod_1.z.string().min(1).max(1000),
+    title: zod_1.z.string().min(1).max(80).optional(),
+    negativeTags: zod_1.z.string().max(1000).optional(),
+    vocalGender: zod_1.z.nativeEnum(enums_1.MUSIC_VOCAL_GENDER).optional(),
+});
+exports.MusicEditRequestSchema = zod_1.z
+    .object({
+    actionType: zod_1.z.nativeEnum(enums_1.MUSIC_AUDIO_ACTION_TYPE),
+    modelId: zod_1.z.string().uuid().optional(),
+    params: zod_1.z.unknown(),
+    userId: zod_1.z.string().optional(),
+    unregisteredUserId: zod_1.z.string().optional(),
+    userBalance: zod_1.z.number(),
+})
+    .superRefine((data, ctx) => {
+    const requiresModel = ![
+        enums_1.MUSIC_AUDIO_ACTION_TYPE.REMOVE_VOCALS,
+        enums_1.MUSIC_AUDIO_ACTION_TYPE.EXTRACT_VOCALS,
+    ].includes(data.actionType);
+    if (requiresModel && !data.modelId) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'modelId is required',
+            path: ['modelId'],
+        });
+    }
+    const paramsValidation = data.actionType === enums_1.MUSIC_AUDIO_ACTION_TYPE.REMOVE_VOCALS ||
+        data.actionType === enums_1.MUSIC_AUDIO_ACTION_TYPE.EXTRACT_VOCALS
+        ? exports.MusicSeparateVocalsParamsSchema.safeParse(data.params)
+        : data.actionType === enums_1.MUSIC_AUDIO_ACTION_TYPE.COVER
+            ? exports.MusicUploadCoverParamsSchema.safeParse(data.params)
+            : data.actionType === enums_1.MUSIC_AUDIO_ACTION_TYPE.EXTEND
+                ? exports.MusicUploadExtendParamsSchema.safeParse(data.params)
+                : data.actionType === enums_1.MUSIC_AUDIO_ACTION_TYPE.ADD_INSTRUMENTAL
+                    ? exports.MusicAddInstrumentalParamsSchema.safeParse(data.params)
+                    : exports.MusicAddVocalsParamsSchema.safeParse(data.params);
+    if (!paramsValidation.success) {
+        for (const issue of paramsValidation.error.issues) {
+            ctx.addIssue(Object.assign(Object.assign({}, issue), { path: ['params', ...issue.path] }));
+        }
+    }
+});
+exports.MusicEditActionResultSchema = zod_1.z.object({
+    actionType: zod_1.z.nativeEnum(enums_1.MUSIC_AUDIO_ACTION_TYPE),
+    url: zod_1.z.string(),
+    vocalUrl: zod_1.z.string().optional(),
+    instrumentalUrl: zod_1.z.string().optional(),
+    originUrl: zod_1.z.string().optional(),
+    price: zod_1.z.number(),
+});
+exports.MusicAnyJobParamsSchema = zod_1.z.union([
+    exports.MusicJobParamsSchema,
+    exports.MusicUploadCoverParamsSchema,
+    exports.MusicUploadExtendParamsSchema,
+    exports.MusicAddInstrumentalParamsSchema,
+    exports.MusicAddVocalsParamsSchema,
+]);
+exports.MusicExecuteRequestSchema = zod_1.z
+    .object({
+    actionType: zod_1.z
+        .nativeEnum(enums_1.MUSIC_GENERATION_ACTION_TYPE)
+        .optional()
+        .default(enums_1.MUSIC_GENERATION_ACTION_TYPE.GENERATE),
+    modelId: zod_1.z.string().uuid().optional(),
+    params: zod_1.z.unknown(),
+})
+    .superRefine((data, ctx) => {
+    if (data.actionType !== enums_1.MUSIC_GENERATION_ACTION_TYPE.GENERATE_LYRICS && !data.modelId) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'modelId is required',
+            path: ['modelId'],
+        });
+    }
+    const paramsValidation = data.actionType === enums_1.MUSIC_GENERATION_ACTION_TYPE.GENERATE_LYRICS
+        ? exports.MusicLyricsParamsSchema.safeParse(data.params)
+        : data.actionType === enums_1.MUSIC_GENERATION_ACTION_TYPE.BACKGROUND
+            ? exports.MusicBackgroundParamsSchema.safeParse(data.params)
+            : exports.MusicJobParamsSchema.safeParse(data.params);
+    if (!paramsValidation.success) {
+        for (const issue of paramsValidation.error.issues) {
+            ctx.addIssue(Object.assign(Object.assign({}, issue), { path: ['params', ...issue.path] }));
+        }
+    }
+});
 exports.MusicJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     prompt: zod_1.z.string(),
@@ -41,7 +172,7 @@ exports.MusicJobSchema = zod_1.z.object({
     error: zod_1.z.string().nullable(),
     modelId: zod_1.z.string(),
     price: zod_1.z.number(),
-    params: exports.MusicJobParamsSchema,
+    params: exports.MusicAnyJobParamsSchema,
     tracks: zod_1.z.array(music_track_schema_1.MusicTrackSchema),
     attempts: zod_1.z.array(zod_1.z.any()),
     userId: zod_1.z.string().nullable().optional(),

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MusicPlaylistSchema = void 0;
+const zod_1 = require("zod");
+const music_track_schema_1 = require("./music-track.schema");
+exports.MusicPlaylistSchema = zod_1.z.object({
+    uuid: zod_1.z.string().uuid(),
+    title: zod_1.z.string(),
+    tracks: zod_1.z.array(music_track_schema_1.MusicTrackSchema).optional(),
+    trackCount: zod_1.z.number(),
+    userId: zod_1.z.string().uuid().nullable().optional(),
+    unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

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

@@ -2,13 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MusicTrackSchema = void 0;
 const zod_1 = require("zod");
+const common_1 = require("../../common");
+const MusicTrackAudioFileSchema = common_1.AttachedFileSchema.pick({
+    uuid: true,
+    url: true,
+    mimeType: true,
+}).extend({
+    duration: zod_1.z.number().nullable(),
+    originalName: zod_1.z.string().nullable().optional(),
+});
 exports.MusicTrackSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
     title: zod_1.z.string(),
     audioId: zod_1.z.string(),
     audioUrl: zod_1.z.string(),
+    audioFile: MusicTrackAudioFileSchema.nullable().optional(),
     coverUrl: zod_1.z.string(),
     prompt: zod_1.z.string().nullable(),
+    fullLyrics: zod_1.z.string().nullable().optional(),
     tags: zod_1.z.string(),
     duration: zod_1.z.number(),
     waveformPeaks: zod_1.z.array(zod_1.z.number()),

package/build/music/queries/find-music-playlists.query.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindMusicPlaylistsQuery = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const music_playlist_schema_1 = require("../models/music-playlist.schema");
+var FindMusicPlaylistsQuery;
+(function (FindMusicPlaylistsQuery) {
+    FindMusicPlaylistsQuery.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'At least userId or unregisteredUserId must be present',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    FindMusicPlaylistsQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.array(music_playlist_schema_1.MusicPlaylistSchema));
+})(FindMusicPlaylistsQuery || (exports.FindMusicPlaylistsQuery = FindMusicPlaylistsQuery = {}));

package/build/music/queries/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./find-music-job-by-id.query"), exports);
 __exportStar(require("./find-music-jobs.query"), exports);
+__exportStar(require("./find-music-playlists.query"), exports);
 __exportStar(require("./get-music-config.query"), exports);
 __exportStar(require("./get-music-config-with-vendors.query"), exports);

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

@@ -3,17 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MUSIC_AMQP_ROUTES = void 0;
 exports.MUSIC_AMQP_ROUTES = {
     EXECUTE: 'tools.music.execute.rpc',
+    EDIT: 'tools.music.edit.rpc',
     GET_PRICE: 'tools.music.get-price.rpc',
     GENERATE_LYRICS: 'tools.music.generate-lyrics.rpc',
+    BOOST_STYLE: 'tools.music.boost-style.rpc',
     CONVERT_TO_WAV: 'tools.music.convert-to-wav.rpc',
     CONFIG: 'tools.music.config.rpc',
     CONFIG_WITH_VENDORS: 'tools.music.config-with-vendors.rpc',
     GET_JOB: 'tools.music.jobs.get.rpc',
     LIST_JOBS: 'tools.music.jobs.list.rpc',
+    LIST_PLAYLISTS: 'tools.music.playlists.list.rpc',
     SET_REACTION: 'tools.music.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.music.jobs.update-title.rpc',
     UPDATE_FAVORITE: 'tools.music.jobs.update-favorite.rpc',
     UPDATE_JOB: 'tools.music.jobs.update.rpc',
+    CREATE_PLAYLIST: 'tools.music.playlists.create.rpc',
+    UPDATE_PLAYLIST: 'tools.music.playlists.update.rpc',
+    DELETE_PLAYLIST: 'tools.music.playlists.delete.rpc',
+    ADD_TRACK_TO_PLAYLIST: 'tools.music.playlists.add-track.rpc',
+    REMOVE_TRACK_FROM_PLAYLIST: 'tools.music.playlists.remove-track.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/music/commands/add-track-to-music-playlist.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicPlaylistSchema } from '../models/music-playlist.schema';
+
+export namespace AddTrackToMusicPlaylistCommand {
+    export const RequestSchema = z
+        .object({
+            playlistId: z.string().uuid(),
+            trackId: z.string().uuid(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicPlaylistSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/boost-music-style.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace BoostMusicStyleCommand {
+    export const RequestSchema = z.object({
+        userId: z.string().uuid().nullable().optional(),
+        unregisteredUserId: z.string().uuid().nullable().optional(),
+        userBalance: z.number(),
+        content: z.string().min(1).max(3000),
+    });
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.object({
+            result: z.string(),
+        }),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/create-music-playlist.command.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicPlaylistSchema } from '../models/music-playlist.schema';
+
+export namespace CreateMusicPlaylistCommand {
+    export const RequestSchema = z
+        .object({
+            title: z.string().min(1).max(80).trim(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicPlaylistSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/delete-music-playlist.command.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+
+export namespace DeleteMusicPlaylistCommand {
+    export const RequestSchema = z
+        .object({
+            uuid: z.string().uuid(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.boolean());
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicEditActionResultSchema, MusicEditRequestSchema, MusicJobSchema } from '../models';
+
+export namespace EditMusicCommand {
+    export const RequestSchema = MusicEditRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(
+        z.union([MusicJobSchema, MusicEditActionResultSchema]),
+    );
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -3,12 +3,17 @@ import { ICommandResponseSchema } from '../../common/models/command-response.sch
 import { LocaleSchema } from '../../common/models/locale.schema';
 import { MusicJobSchema } from '../models/music-job.schema';
 import { MusicJobParamsSchema } from '../models';
+import { MUSIC_GENERATION_ACTION_TYPE } from '../enums';
 
 export namespace GenerateMusicCommand {
     export const RequestSchema = z.object({
         locale: LocaleSchema,
         userId: z.string().uuid().nullable().optional(),
         unregisteredUserId: z.string().uuid().nullable().optional(),
+        actionType: z
+            .nativeEnum(MUSIC_GENERATION_ACTION_TYPE)
+            .optional()
+            .default(MUSIC_GENERATION_ACTION_TYPE.GENERATE),
         modelId: z.string(),
         params: MusicJobParamsSchema,
         tokenReservationId: z.string().uuid(),

package/music/commands/index.ts

@@ -1,12 +1,19 @@
+export * from './add-track-to-music-playlist.command';
+export * from './create-music-playlist.command';
+export * from './delete-music-playlist.command';
+export * from './edit-music.command';
 export * from './delete-music-job-by-uuid.command';
 export * from './delete-all-music-jobs.command';
+export * from './remove-track-from-music-playlist.command';
 export * from './retry-music-job.command';
 export * from './set-reaction-to-music-job.command';
 export * from './generate-music.command';
 export * from './get-music-price.command';
 export * from './update-music-job-title.command';
 export * from './update-music-job-favorite.command';
+export * from './update-music-playlist.command';
 export * from './convert-to-wav.command';
 export * from './generate-lyrics.command';
+export * from './boost-music-style.command';
 export * from './music-model';
 export * from './update-published-status-music-jobs.command';

package/music/commands/remove-track-from-music-playlist.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicPlaylistSchema } from '../models/music-playlist.schema';
+
+export namespace RemoveTrackFromMusicPlaylistCommand {
+    export const RequestSchema = z
+        .object({
+            playlistId: z.string().uuid(),
+            trackId: z.string().uuid(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicPlaylistSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/commands/update-music-playlist.command.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicPlaylistSchema } from '../models/music-playlist.schema';
+
+export namespace UpdateMusicPlaylistCommand {
+    export const RequestSchema = z
+        .object({
+            uuid: z.string().uuid(),
+            title: z.string().min(1).max(80).trim(),
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(MusicPlaylistSchema);
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/enums/index.ts

@@ -4,3 +4,6 @@ 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';
+export * from './music-audio-action-type.enum';
+export * from './music-generation-action-type.enum';
+export * from './music-lyrics-structure.enum';

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

@@ -1,3 +1,10 @@
 export enum MUSIC_ACTION_TYPE {
     LYRICS = 'LYRICS',
+    BOOST_STYLE = 'BOOST_STYLE',
+    REMOVE_VOCALS = 'REMOVE_VOCALS',
+    EXTRACT_VOCALS = 'EXTRACT_VOCALS',
+    COVER = 'COVER',
+    EXTEND = 'EXTEND',
+    ADD_INSTRUMENTAL = 'ADD_INSTRUMENTAL',
+    ADD_VOCALS = 'ADD_VOCALS',
 }

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

@@ -0,0 +1,8 @@
+export enum MUSIC_AUDIO_ACTION_TYPE {
+    REMOVE_VOCALS = 'removeVocals',
+    EXTRACT_VOCALS = 'extractVocals',
+    COVER = 'cover',
+    EXTEND = 'extend',
+    ADD_INSTRUMENTAL = 'addInstrumental',
+    ADD_VOCALS = 'addVocals',
+}

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

@@ -0,0 +1,6 @@
+export enum MUSIC_GENERATION_ACTION_TYPE {
+    GENERATE = 'generate',
+    GIFT = 'gift',
+    BACKGROUND = 'background',
+    GENERATE_LYRICS = 'generateLyrics',
+}

package/music/enums/music-lyrics-structure.enum.ts

@@ -0,0 +1,5 @@
+export enum MUSIC_LYRICS_STRUCTURE {
+    VERSE_CHORUS = 'verse_chorus',
+    WITH_BRIDGE = 'with_bridge',
+    FREE = 'free',
+}

package/music/models/index.ts

@@ -3,4 +3,5 @@ export * from './music-config-with-vendors.schema';
 export * from './music-job.schema';
 export * from './music-model.schema';
 export * from './music-model-with-vendor.schema';
+export * from './music-playlist.schema';
 export * from './music-track.schema';

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

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { AiVendorSchema } from '../../ai-vendor';
 import { MusicModelWithVendorSchema } from './music-model-with-vendor.schema';
+import { MusicAudioActionPricesSchema } from './music-config.schema';
 
 export const MusicConfigWithVendorsSchema = z.object({
     vendors: z.array(AiVendorSchema),
     models: z.array(MusicModelWithVendorSchema),
+    audioActionPrices: MusicAudioActionPricesSchema,
 });
 
 export type MusicConfigWithVendors = z.infer<typeof MusicConfigWithVendorsSchema>;

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

@@ -1,8 +1,16 @@
 import { z } from 'zod';
 import { MusicModelSchema } from './music-model.schema';
+import { MUSIC_AUDIO_ACTION_TYPE } from '../enums';
+
+export const MusicAudioActionPricesSchema = z.record(
+    z.nativeEnum(MUSIC_AUDIO_ACTION_TYPE),
+    z.number(),
+);
 
 export const MusicConfigSchema = z.object({
     models: z.array(MusicModelSchema),
+    audioActionPrices: MusicAudioActionPricesSchema,
 });
 
 export type MusicConfig = z.infer<typeof MusicConfigSchema>;
+export type MusicAudioActionPrices = z.infer<typeof MusicAudioActionPricesSchema>;

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

@@ -1,7 +1,12 @@
 import { z } from 'zod';
 import { JOB_STATUS } from '../../tools';
 import { USER_REACTION } from '../../common';
-import { MUSIC_VOCAL_GENDER } from '../enums';
+import {
+    MUSIC_AUDIO_ACTION_TYPE,
+    MUSIC_GENERATION_ACTION_TYPE,
+    MUSIC_LYRICS_STRUCTURE,
+    MUSIC_VOCAL_GENDER,
+} from '../enums';
 import { MusicTrackSchema } from './music-track.schema';
 import { SUNO_MODE_TYPE } from '../enums/suno-mode-type.enum';
 
@@ -31,6 +36,172 @@ export const MusicJobParamsSchema = z.discriminatedUnion('mode', [
 
 export type MusicJobParams = z.infer<typeof MusicJobParamsSchema>;
 
+export const MusicLyricsParamsSchema = z.object({
+    prompt: z.string().min(1).max(1000),
+    style: z.string().min(1).max(200).optional(),
+    structure: z.nativeEnum(MUSIC_LYRICS_STRUCTURE),
+});
+export type MusicLyricsParams = z.infer<typeof MusicLyricsParamsSchema>;
+
+export const MusicBackgroundParamsSchema = z.object({
+    prompt: z.string().min(1).max(450),
+    style: z.string(),
+});
+export type MusicBackgroundParams = z.infer<typeof MusicBackgroundParamsSchema>;
+
+export const MusicSeparateVocalsParamsSchema = z.object({
+    externalId: z.string().uuid(),
+    audioId: z.string().min(1),
+});
+export type MusicSeparateVocalsParams = z.infer<typeof MusicSeparateVocalsParamsSchema>;
+
+export const MusicUploadCoverParamsSchema = z.object({
+    audioId: z.string().uuid(),
+    uploadUrl: z.string().url(),
+    style: z.string().min(1).max(1000),
+    prompt: z.string().min(1).max(5000).optional(),
+    title: z.string().min(1).max(80).optional(),
+    negativeTags: z.string().max(1000).optional(),
+    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
+    instrumental: z.boolean().optional(),
+});
+export type MusicUploadCoverParams = z.infer<typeof MusicUploadCoverParamsSchema>;
+
+export const MusicUploadExtendParamsSchema = z.object({
+    audioId: z.string().uuid(),
+    uploadUrl: z.string().url(),
+    continueAt: z.number().positive(),
+    prompt: z.string().min(1).max(5000),
+    style: z.string().min(1).max(1000).optional(),
+    title: z.string().min(1).max(80).optional(),
+    negativeTags: z.string().max(1000).optional(),
+    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
+    instrumental: z.boolean().optional(),
+});
+export type MusicUploadExtendParams = z.infer<typeof MusicUploadExtendParamsSchema>;
+
+export const MusicAddInstrumentalParamsSchema = z.object({
+    audioId: z.string().uuid(),
+    uploadUrl: z.string().url(),
+    style: z.string().min(1).max(1000),
+    title: z.string().min(1).max(80).optional(),
+    negativeTags: z.string().max(1000).optional(),
+    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
+});
+export type MusicAddInstrumentalParams = z.infer<typeof MusicAddInstrumentalParamsSchema>;
+
+export const MusicAddVocalsParamsSchema = z.object({
+    audioId: z.string().uuid(),
+    uploadUrl: z.string().url(),
+    prompt: z.string().min(1).max(5000),
+    style: z.string().min(1).max(1000),
+    title: z.string().min(1).max(80).optional(),
+    negativeTags: z.string().max(1000).optional(),
+    vocalGender: z.nativeEnum(MUSIC_VOCAL_GENDER).optional(),
+});
+export type MusicAddVocalsParams = z.infer<typeof MusicAddVocalsParamsSchema>;
+
+export const MusicEditRequestSchema = z
+    .object({
+        actionType: z.nativeEnum(MUSIC_AUDIO_ACTION_TYPE),
+        modelId: z.string().uuid().optional(),
+        params: z.unknown(),
+        userId: z.string().optional(),
+        unregisteredUserId: z.string().optional(),
+        userBalance: z.number(),
+    })
+    .superRefine((data, ctx) => {
+        const requiresModel = ![
+            MUSIC_AUDIO_ACTION_TYPE.REMOVE_VOCALS,
+            MUSIC_AUDIO_ACTION_TYPE.EXTRACT_VOCALS,
+        ].includes(data.actionType);
+
+        if (requiresModel && !data.modelId) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'modelId is required',
+                path: ['modelId'],
+            });
+        }
+
+        const paramsValidation =
+            data.actionType === MUSIC_AUDIO_ACTION_TYPE.REMOVE_VOCALS ||
+            data.actionType === MUSIC_AUDIO_ACTION_TYPE.EXTRACT_VOCALS
+                ? MusicSeparateVocalsParamsSchema.safeParse(data.params)
+                : data.actionType === MUSIC_AUDIO_ACTION_TYPE.COVER
+                  ? MusicUploadCoverParamsSchema.safeParse(data.params)
+                  : data.actionType === MUSIC_AUDIO_ACTION_TYPE.EXTEND
+                    ? MusicUploadExtendParamsSchema.safeParse(data.params)
+                    : data.actionType === MUSIC_AUDIO_ACTION_TYPE.ADD_INSTRUMENTAL
+                      ? MusicAddInstrumentalParamsSchema.safeParse(data.params)
+                      : MusicAddVocalsParamsSchema.safeParse(data.params);
+
+        if (!paramsValidation.success) {
+            for (const issue of paramsValidation.error.issues) {
+                ctx.addIssue({
+                    ...issue,
+                    path: ['params', ...issue.path],
+                });
+            }
+        }
+    });
+export type MusicEditRequest = z.infer<typeof MusicEditRequestSchema>;
+
+export const MusicEditActionResultSchema = z.object({
+    actionType: z.nativeEnum(MUSIC_AUDIO_ACTION_TYPE),
+    url: z.string(),
+    vocalUrl: z.string().optional(),
+    instrumentalUrl: z.string().optional(),
+    originUrl: z.string().optional(),
+    price: z.number(),
+});
+export type MusicEditActionResult = z.infer<typeof MusicEditActionResultSchema>;
+
+export const MusicAnyJobParamsSchema = z.union([
+    MusicJobParamsSchema,
+    MusicUploadCoverParamsSchema,
+    MusicUploadExtendParamsSchema,
+    MusicAddInstrumentalParamsSchema,
+    MusicAddVocalsParamsSchema,
+]);
+export type MusicAnyJobParams = z.infer<typeof MusicAnyJobParamsSchema>;
+
+export const MusicExecuteRequestSchema = z
+    .object({
+        actionType: z
+            .nativeEnum(MUSIC_GENERATION_ACTION_TYPE)
+            .optional()
+            .default(MUSIC_GENERATION_ACTION_TYPE.GENERATE),
+        modelId: z.string().uuid().optional(),
+        params: z.unknown(),
+    })
+    .superRefine((data, ctx) => {
+        if (data.actionType !== MUSIC_GENERATION_ACTION_TYPE.GENERATE_LYRICS && !data.modelId) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: 'modelId is required',
+                path: ['modelId'],
+            });
+        }
+
+        const paramsValidation =
+            data.actionType === MUSIC_GENERATION_ACTION_TYPE.GENERATE_LYRICS
+                ? MusicLyricsParamsSchema.safeParse(data.params)
+                : data.actionType === MUSIC_GENERATION_ACTION_TYPE.BACKGROUND
+                  ? MusicBackgroundParamsSchema.safeParse(data.params)
+                  : MusicJobParamsSchema.safeParse(data.params);
+
+        if (!paramsValidation.success) {
+            for (const issue of paramsValidation.error.issues) {
+                ctx.addIssue({
+                    ...issue,
+                    path: ['params', ...issue.path],
+                });
+            }
+        }
+    });
+export type MusicExecuteRequest = z.infer<typeof MusicExecuteRequestSchema>;
+
 export const MusicJobSchema = z.object({
     uuid: z.string(),
     prompt: z.string(),
@@ -42,7 +213,7 @@ export const MusicJobSchema = z.object({
     error: z.string().nullable(),
     modelId: z.string(),
     price: z.number(),
-    params: MusicJobParamsSchema,
+    params: MusicAnyJobParamsSchema,
     tracks: z.array(MusicTrackSchema),
     attempts: z.array(z.any()),
     userId: z.string().nullable().optional(),

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { MusicTrackSchema } from './music-track.schema';
+
+export const MusicPlaylistSchema = z.object({
+    uuid: z.string().uuid(),
+    title: z.string(),
+    tracks: z.array(MusicTrackSchema).optional(),
+    trackCount: z.number(),
+    userId: z.string().uuid().nullable().optional(),
+    unregisteredUserId: z.string().uuid().nullable().optional(),
+    createdAt: z.date(),
+    updatedAt: z.date(),
+});
+
+export type MusicPlaylist = z.infer<typeof MusicPlaylistSchema>;

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

@@ -1,12 +1,24 @@
 import { z } from 'zod';
+import { AttachedFileSchema } from '../../common';
+
+const MusicTrackAudioFileSchema = AttachedFileSchema.pick({
+    uuid: true,
+    url: true,
+    mimeType: true,
+}).extend({
+    duration: z.number().nullable(),
+    originalName: z.string().nullable().optional(),
+});
 
 export const MusicTrackSchema = z.object({
     uuid: z.string(),
     title: z.string(),
     audioId: z.string(),
     audioUrl: z.string(),
+    audioFile: MusicTrackAudioFileSchema.nullable().optional(),
     coverUrl: z.string(),
     prompt: z.string().nullable(),
+    fullLyrics: z.string().nullable().optional(),
     tags: z.string(),
     duration: z.number(),
     waveformPeaks: z.array(z.number()),

package/music/queries/find-music-playlists.query.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { ICommandResponseSchema } from '../../common/models/command-response.schema';
+import { MusicPlaylistSchema } from '../models/music-playlist.schema';
+
+export namespace FindMusicPlaylistsQuery {
+    export const RequestSchema = z
+        .object({
+            userId: z.string().uuid().optional(),
+            unregisteredUserId: z.string().uuid().optional(),
+        })
+        .refine(
+            (data) => {
+                return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+            },
+            {
+                message: 'At least userId or unregisteredUserId must be present',
+                path: ['userId', 'unregisteredUserId'],
+            },
+        );
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = ICommandResponseSchema(z.array(MusicPlaylistSchema));
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/music/queries/index.ts

@@ -1,4 +1,5 @@
 export * from './find-music-job-by-id.query';
 export * from './find-music-jobs.query';
+export * from './find-music-playlists.query';
 export * from './get-music-config.query';
 export * from './get-music-config-with-vendors.query';

package/music/routes/music.amqp.routes.ts

@@ -1,16 +1,24 @@
 export const MUSIC_AMQP_ROUTES = {
     EXECUTE: 'tools.music.execute.rpc',
+    EDIT: 'tools.music.edit.rpc',
     GET_PRICE: 'tools.music.get-price.rpc',
     GENERATE_LYRICS: 'tools.music.generate-lyrics.rpc',
+    BOOST_STYLE: 'tools.music.boost-style.rpc',
     CONVERT_TO_WAV: 'tools.music.convert-to-wav.rpc',
     CONFIG: 'tools.music.config.rpc',
     CONFIG_WITH_VENDORS: 'tools.music.config-with-vendors.rpc',
     GET_JOB: 'tools.music.jobs.get.rpc',
     LIST_JOBS: 'tools.music.jobs.list.rpc',
+    LIST_PLAYLISTS: 'tools.music.playlists.list.rpc',
     SET_REACTION: 'tools.music.jobs.set-reaction.rpc',
     UPDATE_TITLE: 'tools.music.jobs.update-title.rpc',
     UPDATE_FAVORITE: 'tools.music.jobs.update-favorite.rpc',
     UPDATE_JOB: 'tools.music.jobs.update.rpc',
+    CREATE_PLAYLIST: 'tools.music.playlists.create.rpc',
+    UPDATE_PLAYLIST: 'tools.music.playlists.update.rpc',
+    DELETE_PLAYLIST: 'tools.music.playlists.delete.rpc',
+    ADD_TRACK_TO_PLAYLIST: 'tools.music.playlists.add-track.rpc',
+    REMOVE_TRACK_FROM_PLAYLIST: 'tools.music.playlists.remove-track.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot-tools",
-  "version": "0.2.48",
+  "version": "0.2.50",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {
@@ -12,7 +12,7 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
-    "@purpleschool/rugpt-lib-common": "^0.0.21",
+    "@purpleschool/rugpt-lib-common": "^0.0.72-es-add-test",
     "zod": "^3.25.67"
   }
 }