@purpleschool/gptbot-tools 0.2.52 → 0.2.54

package/marketplace-card/queries/find-marketplace-card-job-by-uuid.query.ts

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

package/marketplace-card/queries/find-marketplace-card-jobs.query.ts

@@ -1,38 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MarketplaceCardJobSchema } from '../models';
-import { JOB_SORT, JOB_STATUS } from '../../tools';
-
-export namespace FindMarketplaceCardJobsQuery {
-    export const RequestSchema = z
-        .object({
-            userId: z.string().uuid().optional(),
-            unregisteredUserId: z.string().uuid().optional(),
-            title: z.string().optional(),
-            isFavorite: z.coerce.boolean().optional(),
-            createdAtSortOrder: z.nativeEnum(JOB_SORT).optional().default(JOB_SORT.DESC),
-            status: z.nativeEnum(JOB_STATUS).optional(),
-            limit: z.coerce.number().min(1).optional(),
-            offset: z.coerce.number().min(0).default(0).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.object({
-            data: z.array(MarketplaceCardJobSchema),
-            page: z.number(),
-            totalPages: z.number(),
-            total: z.number(),
-        }),
-    );
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/marketplace-card/queries/get-marketplace-card-config.query.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema, LocaleRequestSchema } from '../../common';
-import { MarketplaceCardConfigSchema } from '../models';
-
-export namespace GetMarketplaceCardConfigQuery {
-    export const RequestSchema = LocaleRequestSchema;
-    export type Request = z.infer<typeof RequestSchema>;
-    export const ResponseSchema = ICommandResponseSchema(MarketplaceCardConfigSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/marketplace-card/routes/marketplace-card.amqp.routes.ts

@@ -1,14 +0,0 @@
-export const MARKETPLACE_CARD_AMQP_ROUTES = {
-    CONFIG: 'tools.marketplace-card.config.rpc',
-    EXECUTE: 'tools.marketplace-card.execute.rpc',
-    GENERATE_DESCRIPTION: 'tools.marketplace-card.generate-description.rpc',
-    GET_JOB: 'tools.marketplace-card.jobs.get.rpc',
-    GET_PRICE: 'tools.marketplace-card.get-price.rpc',
-    LIST_JOBS: 'tools.marketplace-card.jobs.list.rpc',
-    SET_REACTION: 'tools.marketplace-card.jobs.set-reaction.rpc',
-    SOFT_DELETE: 'tools.marketplace-card.soft-delete.rpc',
-    RETRY: 'tools.marketplace-card.jobs.retry.rpc',
-    UPDATE_TITLE: 'tools.marketplace-card.jobs.update-title.rpc',
-    UPDATE_FAVORITE: 'tools.marketplace-card.jobs.update-favorite.rpc',
-    SOFT_DELETE_ALL: 'tools.marketplace-card.jobs.soft-delete-all.rpc',
-} as const;

package/music/commands/add-track-to-music-playlist.command.ts

@@ -1,26 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/convert-to-wav.command.ts

@@ -1,15 +0,0 @@
-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/create-music-playlist.command.ts

@@ -1,25 +0,0 @@
-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-all-music-jobs.command.ts

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/delete-music-playlist.command.ts

@@ -1,24 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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-lyrics.command.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { LocaleSchema } from '../../common/models/locale.schema';
-
-export namespace GenerateLyricsCommand {
-    export const RequestSchema = z.object({
-        locale: LocaleSchema,
-        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({
-            lyrics: z.string(),
-        }),
-    );
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

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

package/music/commands/get-music-price.command.ts

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicJobParamsSchema } from '../models';
-
-export namespace GetMusicPriceCommand {
-    export const RequestSchema = z.object({
-        modelId: z.string(),
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        params: MusicJobParamsSchema,
-        userHasActiveSubscriptionOrProduct: z.boolean(),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseDataSchema = z.object({
-        price: z.number(),
-    });
-    export type ResponseData = z.infer<typeof ResponseDataSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(ResponseDataSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

package/music/commands/music-model/get-music-model-by-uuid.command.ts

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

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

@@ -1,26 +0,0 @@
-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/retry-music-job.command.ts

@@ -1,22 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicJobParamsSchema, MusicJobSchema } from '../models/music-job.schema';
-import { LocaleSchema } from '../../common';
-
-export namespace RetryMusicJobCommand {
-    export const RequestSchema = z.object({
-        locale: LocaleSchema,
-        uuid: z.string().uuid(),
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        tokenReservationId: z.string().uuid(),
-        precalculatedPrice: z.number(),
-        modelId: z.string().uuid().optional(),
-        params: MusicJobParamsSchema.optional(),
-        userHasActiveSubscriptionOrProduct: z.boolean(),
-    });
-    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

@@ -1,30 +0,0 @@
-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().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);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,16 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicJobSchema } from '../models/music-job.schema';
-
-export namespace UpdateMusicJobFavoriteCommand {
-    export const RequestSchema = z.object({
-        uuid: z.string().uuid(),
-        userId: z.string().uuid().nullable().optional(),
-        unregisteredUserId: z.string().uuid().nullable().optional(),
-        isFavorite: z.boolean(),
-    });
-    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

@@ -1,16 +0,0 @@
-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/commands/update-music-playlist.command.ts

@@ -1,26 +0,0 @@
-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/commands/update-published-status-music-jobs.command.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { ICommandResponseSchema } from '../../common/models/command-response.schema';
-import { MusicJobSchema } from '../models';
-
-export namespace UpdatePublishedStatusMusicJobsCommand {
-    export const RequestSchema = z.object({
-        criteria: z.object({
-            uuid: z.string().uuid(),
-            userId: z.string().uuid().nullable().optional(),
-            unregisteredUserId: z.string().uuid().nullable().optional(),
-        }),
-        data: z
-            .object({
-                musicTrackId: z.string().uuid(),
-                isPublished: z.boolean(),
-                postId: z.string().nullable().optional(),
-            })
-            .refine((data) => (data.isPublished ? !!data.postId : true), {
-                message: 'Post ID is required when track is published',
-                path: ['postId'],
-            }),
-    });
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = ICommandResponseSchema(MusicJobSchema);
-    export type Response = z.infer<typeof ResponseSchema>;
-}

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

@@ -1,10 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-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

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

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

@@ -1,12 +0,0 @@
-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,16 +0,0 @@
-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>;