@purpleschool/gptbot-tools 0.2.59 → 0.2.60

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

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+export declare namespace UpdateSoundGenerationJobTitleCommand {
+    const RequestSchema: z.ZodObject<{
+        uuid: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        title: 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: {
+                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: {
+                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-title.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateSoundGenerationJobTitleCommand = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var UpdateSoundGenerationJobTitleCommand;
+(function (UpdateSoundGenerationJobTitleCommand) {
+    UpdateSoundGenerationJobTitleCommand.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(),
+        title: zod_1.z.string().min(1).max(40),
+    });
+    UpdateSoundGenerationJobTitleCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SoundGenerationJobSchema);
+})(UpdateSoundGenerationJobTitleCommand || (exports.UpdateSoundGenerationJobTitleCommand = UpdateSoundGenerationJobTitleCommand = {}));

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

@@ -0,0 +1 @@
+export * from './sound-generation-strategy.enum';

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

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

package/build/sound-generation/enums/sound-generation-strategy.enum.d.ts

@@ -0,0 +1,3 @@
+export declare enum SOUND_GENERATION_STRATEGY {
+    ELEVENLABS_SOUND_GENERATION = "ELEVENLABS_SOUND_GENERATION"
+}

package/build/sound-generation/enums/sound-generation-strategy.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOUND_GENERATION_STRATEGY = void 0;
+var SOUND_GENERATION_STRATEGY;
+(function (SOUND_GENERATION_STRATEGY) {
+    SOUND_GENERATION_STRATEGY["ELEVENLABS_SOUND_GENERATION"] = "ELEVENLABS_SOUND_GENERATION";
+})(SOUND_GENERATION_STRATEGY || (exports.SOUND_GENERATION_STRATEGY = SOUND_GENERATION_STRATEGY = {}));

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

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

package/build/sound-generation/index.js

@@ -0,0 +1,21 @@
+"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("./commands"), exports);
+__exportStar(require("./enums"), exports);
+__exportStar(require("./models"), exports);
+__exportStar(require("./queries"), exports);
+__exportStar(require("./routes"), exports);

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

@@ -0,0 +1,5 @@
+export * from './sound-generation-config.schema';
+export * from './sound-generation-job.schema';
+export * from './sound-generation-model.schema';
+export * from './sound-generation-params.schema';
+export * from './sound-generation-result.schema';

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

@@ -0,0 +1,21 @@
+"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("./sound-generation-config.schema"), exports);
+__exportStar(require("./sound-generation-job.schema"), exports);
+__exportStar(require("./sound-generation-model.schema"), exports);
+__exportStar(require("./sound-generation-params.schema"), exports);
+__exportStar(require("./sound-generation-result.schema"), exports);

package/build/sound-generation/models/sound-generation-config.schema.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const SoundGenerationConfigSchema: z.ZodObject<{
+    models: z.ZodArray<z.ZodObject<{
+        uuid: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        aiModel: z.ZodString;
+        pricePerSecond: z.ZodNumber;
+        order: z.ZodNumber;
+        status: z.ZodEnum<typeof import("../..").TOOL_MODEL_STATUS>;
+        icons: z.ZodObject<{
+            light: z.ZodObject<{
+                svg: z.ZodString;
+                png: z.ZodString;
+            }, z.core.$strip>;
+            dark: z.ZodObject<{
+                svg: z.ZodString;
+                png: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        strategy: z.ZodEnum<typeof import("..").SOUND_GENERATION_STRATEGY>;
+        maxPromptLength: z.ZodNumber;
+        params: z.ZodObject<{
+            minDurationSeconds: z.ZodNumber;
+            maxDurationSeconds: z.ZodNumber;
+            durationStepSeconds: z.ZodNumber;
+            maxVariations: z.ZodNumber;
+            supportsLoop: z.ZodBoolean;
+        }, z.core.$strip>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SoundGenerationConfig = z.infer<typeof SoundGenerationConfigSchema>;

package/build/sound-generation/models/sound-generation-config.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundGenerationConfigSchema = void 0;
+const zod_1 = require("zod");
+const sound_generation_model_schema_1 = require("./sound-generation-model.schema");
+exports.SoundGenerationConfigSchema = zod_1.z.object({
+    models: zod_1.z.array(sound_generation_model_schema_1.SoundGenerationModelSchema),
+});

package/build/sound-generation/models/sound-generation-job.schema.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { JOB_SCOPE, USER_REACTION } from '../../common';
+import { JOB_STATUS } from '../../tools';
+export declare const SoundGenerationJobSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    prompt: z.ZodString;
+    title: z.ZodString;
+    status: z.ZodEnum<typeof JOB_STATUS>;
+    error: z.ZodNullable<z.ZodString>;
+    internalError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    modelId: z.ZodString;
+    price: z.ZodNumber;
+    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>;
+    results: z.ZodArray<z.ZodObject<{
+        audioUrl: z.ZodString;
+        duration: z.ZodNumber;
+    }, z.core.$strip>>;
+    attempts: z.ZodArray<z.ZodUnknown>;
+    reaction: z.ZodNullable<z.ZodEnum<typeof USER_REACTION>>;
+    dislikeReason: z.ZodNullable<z.ZodString>;
+    scope: z.ZodEnum<typeof JOB_SCOPE>;
+    locale: z.ZodString;
+    processingAttemptId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tokenReservationId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isDeleted: z.ZodBoolean;
+    isFavorite: z.ZodBoolean;
+    createdAt: z.ZodDate;
+    completedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export type SoundGenerationJob = z.infer<typeof SoundGenerationJobSchema>;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundGenerationJobSchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const tools_1 = require("../../tools");
+const sound_generation_params_schema_1 = require("./sound-generation-params.schema");
+const sound_generation_result_schema_1 = require("./sound-generation-result.schema");
+exports.SoundGenerationJobSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    prompt: zod_1.z.string(),
+    title: zod_1.z.string(),
+    status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    error: zod_1.z.string().nullable(),
+    internalError: zod_1.z.string().nullable().optional(),
+    modelId: zod_1.z.string(),
+    price: zod_1.z.number(),
+    params: sound_generation_params_schema_1.SoundGenerationParamsSchema,
+    results: zod_1.z.array(sound_generation_result_schema_1.SoundGenerationResultSchema),
+    attempts: zod_1.z.array(zod_1.z.unknown()),
+    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    dislikeReason: zod_1.z.string().nullable(),
+    scope: zod_1.z.nativeEnum(common_1.JOB_SCOPE),
+    locale: zod_1.z.string(),
+    processingAttemptId: zod_1.z.string().uuid().nullable().optional(),
+    userId: zod_1.z.string().nullable().optional(),
+    unregisteredUserId: zod_1.z.string().nullable().optional(),
+    tokenReservationId: zod_1.z.string().nullable().optional(),
+    isDeleted: zod_1.z.boolean(),
+    isFavorite: zod_1.z.boolean(),
+    createdAt: zod_1.z.date(),
+    completedAt: zod_1.z.date().nullable().optional(),
+    updatedAt: zod_1.z.date(),
+});

package/build/sound-generation/models/sound-generation-model.schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { TOOL_MODEL_STATUS } from '../../common';
+import { SOUND_GENERATION_STRATEGY } from '../enums';
+export declare const SoundGenerationModelParamsSchema: z.ZodObject<{
+    minDurationSeconds: z.ZodNumber;
+    maxDurationSeconds: z.ZodNumber;
+    durationStepSeconds: z.ZodNumber;
+    maxVariations: z.ZodNumber;
+    supportsLoop: z.ZodBoolean;
+}, z.core.$strip>;
+export type SoundGenerationModelParams = z.infer<typeof SoundGenerationModelParamsSchema>;
+export declare const SoundGenerationModelSchema: z.ZodObject<{
+    uuid: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    aiModel: z.ZodString;
+    pricePerSecond: z.ZodNumber;
+    order: z.ZodNumber;
+    status: z.ZodEnum<typeof TOOL_MODEL_STATUS>;
+    icons: z.ZodObject<{
+        light: z.ZodObject<{
+            svg: z.ZodString;
+            png: z.ZodString;
+        }, z.core.$strip>;
+        dark: z.ZodObject<{
+            svg: z.ZodString;
+            png: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    strategy: z.ZodEnum<typeof SOUND_GENERATION_STRATEGY>;
+    maxPromptLength: z.ZodNumber;
+    params: z.ZodObject<{
+        minDurationSeconds: z.ZodNumber;
+        maxDurationSeconds: z.ZodNumber;
+        durationStepSeconds: z.ZodNumber;
+        maxVariations: z.ZodNumber;
+        supportsLoop: z.ZodBoolean;
+    }, z.core.$strip>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, z.core.$strip>;
+export type SoundGenerationModel = z.infer<typeof SoundGenerationModelSchema>;

package/build/sound-generation/models/sound-generation-model.schema.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundGenerationModelSchema = exports.SoundGenerationModelParamsSchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const enums_1 = require("../enums");
+exports.SoundGenerationModelParamsSchema = zod_1.z.object({
+    minDurationSeconds: zod_1.z.number(),
+    maxDurationSeconds: zod_1.z.number(),
+    durationStepSeconds: zod_1.z.number(),
+    maxVariations: zod_1.z.number().int(),
+    supportsLoop: zod_1.z.boolean(),
+});
+exports.SoundGenerationModelSchema = zod_1.z.object({
+    uuid: zod_1.z.string(),
+    title: zod_1.z.string(),
+    description: zod_1.z.string(),
+    aiModel: zod_1.z.string(),
+    pricePerSecond: zod_1.z.number(),
+    order: zod_1.z.number(),
+    status: zod_1.z.nativeEnum(common_1.TOOL_MODEL_STATUS),
+    icons: common_1.IconVariantsSchema,
+    strategy: zod_1.z.nativeEnum(enums_1.SOUND_GENERATION_STRATEGY),
+    maxPromptLength: zod_1.z.number(),
+    params: exports.SoundGenerationModelParamsSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+});

package/build/sound-generation/models/sound-generation-params.schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const SoundGenerationParamsSchema: 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>;
+export type SoundGenerationParams = z.infer<typeof SoundGenerationParamsSchema>;

package/build/sound-generation/models/sound-generation-params.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundGenerationParamsSchema = void 0;
+const zod_1 = require("zod");
+exports.SoundGenerationParamsSchema = zod_1.z.object({
+    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),
+    loop: zod_1.z.boolean().default(false),
+    promptInfluence: zod_1.z.number().min(0).max(1).default(0.3),
+});

package/build/sound-generation/models/sound-generation-result.schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const SoundGenerationResultSchema: z.ZodObject<{
+    audioUrl: z.ZodString;
+    duration: z.ZodNumber;
+}, z.core.$strip>;
+export type SoundGenerationResult = z.infer<typeof SoundGenerationResultSchema>;

package/build/sound-generation/models/sound-generation-result.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoundGenerationResultSchema = void 0;
+const zod_1 = require("zod");
+exports.SoundGenerationResultSchema = zod_1.z.object({
+    audioUrl: zod_1.z.string().url(),
+    duration: zod_1.z.number().nonnegative(),
+});

package/build/sound-generation/queries/find-sound-generation-job-by-id.query.d.ts

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+export declare namespace FindSoundGenerationJobByIdQuery {
+    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<{
+            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: {
+                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: {
+                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/queries/find-sound-generation-job-by-id.query.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindSoundGenerationJobByIdQuery = void 0;
+const zod_1 = require("zod");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var FindSoundGenerationJobByIdQuery;
+(function (FindSoundGenerationJobByIdQuery) {
+    FindSoundGenerationJobByIdQuery.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(),
+    });
+    FindSoundGenerationJobByIdQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SoundGenerationJobSchema);
+})(FindSoundGenerationJobByIdQuery || (exports.FindSoundGenerationJobByIdQuery = FindSoundGenerationJobByIdQuery = {}));

package/build/sound-generation/queries/find-sound-generation-jobs.query.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { JOB_SCOPE } from '../../common';
+import { JOB_SORT, JOB_STATUS } from '../../tools';
+export declare namespace FindSoundGenerationJobsQuery {
+    const RequestSchema: z.ZodObject<{
+        userId: z.ZodOptional<z.ZodString>;
+        unregisteredUserId: z.ZodOptional<z.ZodString>;
+        scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>>;
+        title: z.ZodOptional<z.ZodString>;
+        isFavorite: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
+        createdAtSortOrder: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SORT>>>;
+        status: z.ZodOptional<z.ZodEnum<typeof JOB_STATUS>>;
+        limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+        offset: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<unknown>>>;
+    }, z.core.$strip>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        isSuccess: z.ZodBoolean;
+        data: z.ZodOptional<z.ZodType<{
+            data: {
+                uuid: string;
+                prompt: string;
+                title: string;
+                status: JOB_STATUS;
+                error: string | null;
+                internalError?: string | null | undefined;
+                modelId: string;
+                price: number;
+                params: {
+                    durationInSeconds?: number | undefined;
+                    variations: number;
+                    loop: boolean;
+                    promptInfluence: number;
+                };
+                results: {
+                    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;
+            }[];
+            page: number;
+            totalPages: number;
+            total: number;
+        }, unknown, z.core.$ZodTypeInternals<{
+            data: {
+                uuid: string;
+                prompt: string;
+                title: string;
+                status: JOB_STATUS;
+                error: string | null;
+                internalError?: string | null | undefined;
+                modelId: string;
+                price: number;
+                params: {
+                    durationInSeconds?: number | undefined;
+                    variations: number;
+                    loop: boolean;
+                    promptInfluence: number;
+                };
+                results: {
+                    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;
+            }[];
+            page: number;
+            totalPages: number;
+            total: 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/queries/find-sound-generation-jobs.query.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindSoundGenerationJobsQuery = void 0;
+const zod_1 = require("zod");
+const common_1 = require("../../common");
+const tools_1 = require("../../tools");
+const command_response_schema_1 = require("../../common/models/command-response.schema");
+const models_1 = require("../models");
+var FindSoundGenerationJobsQuery;
+(function (FindSoundGenerationJobsQuery) {
+    FindSoundGenerationJobsQuery.RequestSchema = zod_1.z
+        .object({
+        userId: zod_1.z.string().uuid().optional(),
+        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        scope: zod_1.z.nativeEnum(common_1.JOB_SCOPE).optional().default(common_1.JOB_SCOPE.TOOL),
+        title: zod_1.z.string().optional(),
+        isFavorite: zod_1.z.coerce.boolean().optional(),
+        createdAtSortOrder: zod_1.z.nativeEnum(tools_1.JOB_SORT).optional().default(tools_1.JOB_SORT.DESC),
+        status: zod_1.z.nativeEnum(tools_1.JOB_STATUS).optional(),
+        limit: zod_1.z.coerce.number().int().min(1).optional(),
+        offset: zod_1.z.coerce.number().int().min(0).default(0).optional(),
+    })
+        .refine((data) => {
+        return Boolean(data.userId) !== Boolean(data.unregisteredUserId);
+    }, {
+        message: 'Exactly one of userId or unregisteredUserId is required',
+        path: ['userId', 'unregisteredUserId'],
+    });
+    FindSoundGenerationJobsQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.object({
+        data: zod_1.z.array(models_1.SoundGenerationJobSchema),
+        page: zod_1.z.number(),
+        totalPages: zod_1.z.number(),
+        total: zod_1.z.number(),
+    }));
+})(FindSoundGenerationJobsQuery || (exports.FindSoundGenerationJobsQuery = FindSoundGenerationJobsQuery = {}));