@purpleschool/gptbot-tools 0.2.64-stage2 → 0.2.65-stage2

package/build/index.d.ts

@@ -22,6 +22,7 @@ export * from './html-page-builder';
 export * from './tool-workspace';
 export * from './diagrams';
 export * from './image-recognition';
+export * from './sound-generation';
 export * from './photo-sessions';
 import * as common from './common';
 import * as paraphrase from './paraphrase';
@@ -47,6 +48,7 @@ import * as accountMerge from './account-merge';
 import * as toolWorkspace from './tool-workspace';
 import * as diagrams from './diagrams';
 import * as imageRecognition from './image-recognition';
+import * as soundGeneration from './sound-generation';
 import * as photoSessions from './photo-sessions';
 export declare namespace ToolService {
     export import Common = common;
@@ -73,5 +75,6 @@ export declare namespace ToolService {
     export import ToolWorkspace = toolWorkspace;
     export import Diagrams = diagrams;
     export import ImageRecognition = imageRecognition;
+    export import SoundGeneration = soundGeneration;
     export import PhotoSessions = photoSessions;
 }

package/build/index.js

@@ -61,6 +61,7 @@ __exportStar(require("./html-page-builder"), exports);
 __exportStar(require("./tool-workspace"), exports);
 __exportStar(require("./diagrams"), exports);
 __exportStar(require("./image-recognition"), exports);
+__exportStar(require("./sound-generation"), exports);
 __exportStar(require("./photo-sessions"), exports);
 const common = __importStar(require("./common"));
 const paraphrase = __importStar(require("./paraphrase"));
@@ -86,6 +87,7 @@ const accountMerge = __importStar(require("./account-merge"));
 const toolWorkspace = __importStar(require("./tool-workspace"));
 const diagrams = __importStar(require("./diagrams"));
 const imageRecognition = __importStar(require("./image-recognition"));
+const soundGeneration = __importStar(require("./sound-generation"));
 const photoSessions = __importStar(require("./photo-sessions"));
 var ToolService;
 (function (ToolService) {
@@ -113,5 +115,6 @@ var ToolService;
     ToolService.ToolWorkspace = toolWorkspace;
     ToolService.Diagrams = diagrams;
     ToolService.ImageRecognition = imageRecognition;
+    ToolService.SoundGeneration = soundGeneration;
     ToolService.PhotoSessions = photoSessions;
 })(ToolService || (exports.ToolService = ToolService = {}));

package/build/sound-generation/commands/delete-all-sound-generation-jobs.command.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { JOB_SCOPE } from '../../common';
+export declare namespace DeleteAllSoundGenerationJobsCommand {
+    const RequestSchema: z.ZodObject<{
+        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>>;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/sound-generation/commands/delete-all-sound-generation-jobs.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAllSoundGenerationJobsCommand = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+var DeleteAllSoundGenerationJobsCommand;
+(function (DeleteAllSoundGenerationJobsCommand) {
+    DeleteAllSoundGenerationJobsCommand.RequestSchema = zod_1.z.object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        scope: zod_1.z.nativeEnum(common_1.JOB_SCOPE).optional().default(common_1.JOB_SCOPE.TOOL),
+    });
+    DeleteAllSoundGenerationJobsCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.boolean());
+})(DeleteAllSoundGenerationJobsCommand || (exports.DeleteAllSoundGenerationJobsCommand = DeleteAllSoundGenerationJobsCommand = {}));

package/build/sound-generation/commands/delete-sound-generation-job-by-uuid.command.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare namespace DeleteSoundGenerationJobByUuidCommand {
+    const RequestSchema: z.ZodObject<{
+        uuid: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<boolean, unknown, z.core.$ZodTypeInternals<boolean, unknown>>>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/sound-generation/commands/delete-sound-generation-job-by-uuid.command.js

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

package/build/sound-generation/commands/get-sound-generation-price.command.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare namespace GetSoundGenerationPriceCommand {
+    const RequestSchema: z.ZodObject<{
+        modelId: z.ZodString;
+        durationInSeconds: z.ZodOptional<z.ZodNumber>;
+        variations: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseDataSchema: z.ZodObject<{
+        price: z.ZodNumber;
+    }, z.core.$strip>;
+    type ResponseData = z.infer<typeof ResponseDataSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<{
+            price: number;
+        }, unknown, z.core.$ZodTypeInternals<{
+            price: number;
+        }, unknown>>>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/sound-generation/commands/get-sound-generation-price.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSoundGenerationPriceCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+var GetSoundGenerationPriceCommand;
+(function (GetSoundGenerationPriceCommand) {
+    GetSoundGenerationPriceCommand.RequestSchema = zod_1.z.object({
+        modelId: zod_1.z.string().uuid(),
+        durationInSeconds: zod_1.z.number().min(0.5).max(30).multipleOf(0.5).optional(),
+        variations: zod_1.z.number().int().min(1).max(4).default(1),
+    });
+    GetSoundGenerationPriceCommand.ResponseDataSchema = zod_1.z.object({
+        price: zod_1.z.number(),
+    });
+    GetSoundGenerationPriceCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(GetSoundGenerationPriceCommand.ResponseDataSchema);
+})(GetSoundGenerationPriceCommand || (exports.GetSoundGenerationPriceCommand = GetSoundGenerationPriceCommand = {}));

package/build/sound-generation/commands/index.d.ts

@@ -0,0 +1,8 @@
+export * from './delete-all-sound-generation-jobs.command';
+export * from './delete-sound-generation-job-by-uuid.command';
+export * from './get-sound-generation-price.command';
+export * from './retry-sound-generation-job.command';
+export * from './set-reaction-to-sound-generation-job.command';
+export * from './sound-generation.command';
+export * from './update-sound-generation-job-favorite.command';
+export * from './update-sound-generation-job-title.command';

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

@@ -0,0 +1,24 @@
+"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("./delete-all-sound-generation-jobs.command"), exports);
+__exportStar(require("./delete-sound-generation-job-by-uuid.command"), exports);
+__exportStar(require("./get-sound-generation-price.command"), exports);
+__exportStar(require("./retry-sound-generation-job.command"), exports);
+__exportStar(require("./set-reaction-to-sound-generation-job.command"), exports);
+__exportStar(require("./sound-generation.command"), exports);
+__exportStar(require("./update-sound-generation-job-favorite.command"), exports);
+__exportStar(require("./update-sound-generation-job-title.command"), exports);

package/build/sound-generation/commands/retry-sound-generation-job.command.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export declare namespace RetrySoundGenerationJobCommand {
+    const RequestSchema: z.ZodObject<{
+        uuid: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tokenReservationId: z.ZodString;
+        precalculatedPrice: z.ZodNumber;
+        prompt: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        params: z.ZodOptional<z.ZodObject<{
+            durationInSeconds: z.ZodOptional<z.ZodNumber>;
+            variations: z.ZodDefault<z.ZodNumber>;
+            loop: z.ZodDefault<z.ZodBoolean>;
+            promptInfluence: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: import("../..").USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: import("../..").JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown, z.core.$ZodTypeInternals<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: import("../..").USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: import("../..").JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown>>>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/sound-generation/commands/retry-sound-generation-job.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetrySoundGenerationJobCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var RetrySoundGenerationJobCommand;
+(function (RetrySoundGenerationJobCommand) {
+    RetrySoundGenerationJobCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        tokenReservationId: zod_1.z.string().uuid(),
+        precalculatedPrice: zod_1.z.number().positive(),
+        prompt: zod_1.z.string().optional(),
+        modelId: zod_1.z.string().uuid().optional(),
+        params: models_1.SoundGenerationParamsSchema.optional(),
+    });
+    RetrySoundGenerationJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SoundGenerationJobSchema);
+})(RetrySoundGenerationJobCommand || (exports.RetrySoundGenerationJobCommand = RetrySoundGenerationJobCommand = {}));

package/build/sound-generation/commands/set-reaction-to-sound-generation-job.command.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { USER_REACTION } from '../../common';
+export declare namespace SetReactionToSoundGenerationJobCommand {
+    const RequestSchema: z.ZodObject<{
+        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodString;
+        reaction: z.ZodNullable<z.ZodEnum<typeof USER_REACTION>>;
+        dislikeReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: import("../..").JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown, z.core.$ZodTypeInternals<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: import("../..").JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown>>>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetReactionToSoundGenerationJobCommand = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var SetReactionToSoundGenerationJobCommand;
+(function (SetReactionToSoundGenerationJobCommand) {
+    SetReactionToSoundGenerationJobCommand.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        uuid: zod_1.z.string().uuid(),
+        reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+        dislikeReason: zod_1.z.string().nullable().default(null),
+    })
+        .refine((data) => {
+        if (data.reaction !== common_1.USER_REACTION.DISLIKED && data.dislikeReason) {
+            return false;
+        }
+        return true;
+    }, {
+        message: 'Dislike reason is not allowed when reaction is not disliked',
+    });
+    SetReactionToSoundGenerationJobCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SoundGenerationJobSchema);
+})(SetReactionToSoundGenerationJobCommand || (exports.SetReactionToSoundGenerationJobCommand = SetReactionToSoundGenerationJobCommand = {}));

package/build/sound-generation/commands/sound-generation.command.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { JOB_SCOPE } from '../../common';
+export declare namespace SoundGenerationCommand {
+    const RequestSchema: z.ZodObject<{
+        locale: z.ZodEnum<typeof import("@purpleschool/rugpt-lib-common").LOCALE>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>>;
+        prompt: z.ZodString;
+        modelId: z.ZodString;
+        params: z.ZodObject<{
+            durationInSeconds: z.ZodOptional<z.ZodNumber>;
+            variations: z.ZodDefault<z.ZodNumber>;
+            loop: z.ZodDefault<z.ZodBoolean>;
+            promptInfluence: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        tokenReservationId: z.ZodString;
+        precalculatedPrice: z.ZodNumber;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: import("../..").USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown, z.core.$ZodTypeInternals<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: import("../..").USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown>>>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/sound-generation/commands/sound-generation.command.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundGenerationCommand = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const models_1 = require("../models");
+const sound_generation_params_schema_1 = require("../models/sound-generation-params.schema");
+var SoundGenerationCommand;
+(function (SoundGenerationCommand) {
+    SoundGenerationCommand.RequestSchema = zod_1.z
+        .object({
+        locale: common_1.LocaleSchema,
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        scope: zod_1.z.nativeEnum(common_1.JOB_SCOPE).optional().default(common_1.JOB_SCOPE.TOOL),
+        prompt: zod_1.z.string().min(1),
+        modelId: zod_1.z.string().uuid(),
+        params: sound_generation_params_schema_1.SoundGenerationParamsSchema,
+        tokenReservationId: zod_1.z.string().uuid(),
+        precalculatedPrice: zod_1.z.number().positive(),
+    })
+        .refine((data) => Boolean(data.userId) !== Boolean(data.unregisteredUserId), {
+        message: 'Exactly one of userId or unregisteredUserId is required',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    SoundGenerationCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.SoundGenerationJobSchema);
+})(SoundGenerationCommand || (exports.SoundGenerationCommand = SoundGenerationCommand = {}));

package/build/sound-generation/commands/update-sound-generation-job-favorite.command.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+export declare namespace UpdateSoundGenerationJobFavoriteCommand {
+    const RequestSchema: z.ZodObject<{
+        uuid: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isFavorite: z.ZodBoolean;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: import("../..").USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: import("../..").JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown, z.core.$ZodTypeInternals<{
+            uuid: string;
+            prompt: string;
+            title: string;
+            status: import("../..").JOB_STATUS;
+            error: string | null;
+            internalError?: string | null | undefined;
+            modelId: string;
+            price: number;
+            params: {
+                durationInSeconds?: number | undefined;
+                variations: number;
+                loop: boolean;
+                promptInfluence: number;
+            };
+            results: {
+                uuid: string;
+                audioUrl: string;
+                duration: number;
+            }[];
+            attempts: unknown[];
+            reaction: import("../..").USER_REACTION | null;
+            dislikeReason: string | null;
+            scope: import("../..").JOB_SCOPE;
+            locale: string;
+            processingAttemptId?: string | null | undefined;
+            userId?: string | null | undefined;
+            unregisteredUserId?: string | null | undefined;
+            tokenReservationId?: string | null | undefined;
+            isDeleted: boolean;
+            isFavorite: boolean;
+            createdAt: Date;
+            completedAt?: Date | null | undefined;
+            updatedAt: Date;
+        }, unknown>>>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/sound-generation/commands/update-sound-generation-job-favorite.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateSoundGenerationJobFavoriteCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var UpdateSoundGenerationJobFavoriteCommand;
+(function (UpdateSoundGenerationJobFavoriteCommand) {
+    UpdateSoundGenerationJobFavoriteCommand.RequestSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        userId: zod_1.z.string().uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        isFavorite: zod_1.z.boolean(),
+    });
+    UpdateSoundGenerationJobFavoriteCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SoundGenerationJobSchema);
+})(UpdateSoundGenerationJobFavoriteCommand || (exports.UpdateSoundGenerationJobFavoriteCommand = UpdateSoundGenerationJobFavoriteCommand = {}));