@purpleschool/gptbot-tools 0.2.76 → 0.2.78-stage-2

package/build/spell-corrector/commands/spell-corrector.command.js

@@ -8,13 +8,13 @@ var SpellCorrectorCommand;
 (function (SpellCorrectorCommand) {
     SpellCorrectorCommand.RequestSchema = zod_1.z
         .object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        requestId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        requestId: zod_1.z.uuid(),
         prompt: zod_1.z.string().optional(),
         document: models_1.SpellCorrectorDocumentInputSchema.optional(),
-        modelId: zod_1.z.string().uuid(),
-        tokenReservationId: zod_1.z.string().uuid(),
+        modelId: zod_1.z.uuid(),
+        tokenReservationId: zod_1.z.uuid(),
         precalculatedPrice: zod_1.z.number(),
         userHasActiveSubscriptionOrProduct: zod_1.z.boolean(),
         mock: zod_1.z.boolean().optional(),

package/build/spell-corrector/commands/update-spell-corrector-job-favorite.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdateSpellCorrectorJobFavoriteCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         isFavorite: z.ZodBoolean;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/spell-corrector/commands/update-spell-corrector-job-favorite.command.js

@@ -7,9 +7,9 @@ const spell_corrector_job_schema_1 = require("../models/spell-corrector-job.sche
 var UpdateSpellCorrectorJobFavoriteCommand;
 (function (UpdateSpellCorrectorJobFavoriteCommand) {
     UpdateSpellCorrectorJobFavoriteCommand.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         isFavorite: zod_1.z.boolean(),
     });
     UpdateSpellCorrectorJobFavoriteCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(spell_corrector_job_schema_1.SpellCorrectorJobSchema);

package/build/spell-corrector/commands/update-spell-corrector-job-title.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdateSpellCorrectorJobTitleCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         title: z.ZodString;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/spell-corrector/commands/update-spell-corrector-job-title.command.js

@@ -7,9 +7,9 @@ const models_1 = require("../models");
 var UpdateSpellCorrectorJobTitleCommand;
 (function (UpdateSpellCorrectorJobTitleCommand) {
     UpdateSpellCorrectorJobTitleCommand.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         title: zod_1.z.string().min(1).max(40),
     });
     UpdateSpellCorrectorJobTitleCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SpellCorrectorJobSchema);

package/build/spell-corrector/models/spell-corrector-job.schema.d.ts

@@ -4,7 +4,7 @@ import { USER_REACTION } from '../../common';
 import { SPELL_CORRECTOR_INPUT_KIND } from '../enums';
 export declare const SpellCorrectorJobSchema: z.ZodObject<{
     uuid: z.ZodString;
-    requestId: z.ZodNullable<z.ZodString>;
+    requestId: z.ZodNullable<z.ZodUUID>;
     inputKind: z.ZodEnum<typeof SPELL_CORRECTOR_INPUT_KIND>;
     sourceDocument: z.ZodNullable<z.ZodObject<{
         uuid: z.ZodString;

package/build/spell-corrector/models/spell-corrector-job.schema.js

@@ -9,8 +9,8 @@ const spell_corrector_correction_statistics_schema_1 = require("./spell-correcto
 const enums_1 = require("../enums");
 exports.SpellCorrectorJobSchema = zod_1.z.object({
     uuid: zod_1.z.string(),
-    requestId: zod_1.z.string().uuid().nullable(),
-    inputKind: zod_1.z.nativeEnum(enums_1.SPELL_CORRECTOR_INPUT_KIND),
+    requestId: zod_1.z.uuid().nullable(),
+    inputKind: zod_1.z.enum(enums_1.SPELL_CORRECTOR_INPUT_KIND),
     sourceDocument: spell_corrector_document_schema_1.SpellCorrectorDocumentMetadataSchema.nullable(),
     statistics: spell_corrector_correction_statistics_schema_1.SpellCorrectorCorrectionStatisticsSchema.nullable().default(null),
     outputDocument: spell_corrector_document_schema_1.SpellCorrectorDocumentMetadataSchema.nullable().default(null),
@@ -23,10 +23,10 @@ exports.SpellCorrectorJobSchema = zod_1.z.object({
     lettersChanged: zod_1.z.number().nullable(),
     editOperations: zod_1.z.number().nullable(),
     price: zod_1.z.number(),
-    status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    status: zod_1.z.enum(tools_1.JOB_STATUS),
     title: zod_1.z.string(),
     error: zod_1.z.string().nullable(),
-    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    reaction: zod_1.z.enum(common_1.USER_REACTION).nullable(),
     dislikeReason: zod_1.z.string().nullable(),
     modelId: zod_1.z.string(),
     tokenReservationId: zod_1.z.string().nullable().optional(),

package/build/spell-corrector/models/spell-corrector-model.schema.js

@@ -15,8 +15,8 @@ exports.SpellCorrectorModelSchema = zod_1.z.object({
     freeMaxPromptLength: zod_1.z.number().nullable(),
     maxPromptLength: zod_1.z.number().nullable(),
     aiModel: zod_1.z.string(),
-    status: zod_1.z.nativeEnum(common_1.TOOL_MODEL_STATUS),
-    reasoningEffort: zod_1.z.nativeEnum(common_1.REASONING_EFFORT).nullable().optional(),
+    status: zod_1.z.enum(common_1.TOOL_MODEL_STATUS),
+    reasoningEffort: zod_1.z.enum(common_1.REASONING_EFFORT).nullable().optional(),
     order: zod_1.z.number(),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),

package/build/spell-corrector/queries/find-spell-corrector-job-by-uuid.query.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace FindSpellCorrectorJobByUuidQuery {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/spell-corrector/queries/find-spell-corrector-job-by-uuid.query.js

@@ -7,9 +7,9 @@ const models_1 = require("../models");
 var FindSpellCorrectorJobByUuidQuery;
 (function (FindSpellCorrectorJobByUuidQuery) {
     FindSpellCorrectorJobByUuidQuery.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
     });
     FindSpellCorrectorJobByUuidQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.SpellCorrectorJobSchema);
 })(FindSpellCorrectorJobByUuidQuery || (exports.FindSpellCorrectorJobByUuidQuery = FindSpellCorrectorJobByUuidQuery = {}));

package/build/spell-corrector/queries/find-spell-corrector-jobs.query.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { JOB_SORT, JOB_STATUS } from '../../tools';
 export declare namespace FindSpellCorrectorJobsQuery {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodString>;
-        unregisteredUserId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodUUID>;
+        unregisteredUserId: z.ZodOptional<z.ZodUUID>;
         title: z.ZodOptional<z.ZodString>;
         isFavorite: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;
         createdAtSortOrder: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SORT>>>;

package/build/spell-corrector/queries/find-spell-corrector-jobs.query.js

@@ -9,12 +9,12 @@ var FindSpellCorrectorJobsQuery;
 (function (FindSpellCorrectorJobsQuery) {
     FindSpellCorrectorJobsQuery.RequestSchema = zod_1.z
         .object({
-        userId: zod_1.z.string().uuid().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        userId: zod_1.z.uuid().optional(),
+        unregisteredUserId: zod_1.z.uuid().optional(),
         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(),
+        createdAtSortOrder: zod_1.z.enum(tools_1.JOB_SORT).optional().default(tools_1.JOB_SORT.DESC),
+        status: zod_1.z.enum(tools_1.JOB_STATUS).optional(),
         limit: zod_1.z.coerce.number().min(1).optional(),
         offset: zod_1.z.coerce.number().min(0).default(0).optional(),
     })

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

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { JOB_SCOPE } from '../../common';
 export declare namespace DeleteAllSTTJobsCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/stt/commands/delete-all-stt-jobs.command.js

@@ -7,9 +7,9 @@ const command_response_schema_1 = require("../../common/models/command-response.
 var DeleteAllSTTJobsCommand;
 (function (DeleteAllSTTJobsCommand) {
     DeleteAllSTTJobsCommand.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),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        scope: zod_1.z.enum(common_1.JOB_SCOPE).optional().default(common_1.JOB_SCOPE.TOOL),
     });
     DeleteAllSTTJobsCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());
 })(DeleteAllSTTJobsCommand || (exports.DeleteAllSTTJobsCommand = DeleteAllSTTJobsCommand = {}));

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

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace DeleteSTTJobByUuidCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         uuid: z.ZodString;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

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

@@ -6,8 +6,8 @@ const command_response_schema_1 = require("../../common/models/command-response.
 var DeleteSTTJobByUuidCommand;
 (function (DeleteSTTJobByUuidCommand) {
     DeleteSTTJobByUuidCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         uuid: zod_1.z.string(),
     });
     DeleteSTTJobByUuidCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(zod_1.z.boolean());

package/build/stt/commands/retry-stt-job.command.d.ts

@@ -1,10 +1,10 @@
 import { z } from 'zod';
 export declare namespace RetrySTTJobCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        tokenReservationId: z.ZodString;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        tokenReservationId: z.ZodUUID;
         precalculatedPrice: z.ZodNumber;
         mock: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;

package/build/stt/commands/retry-stt-job.command.js

@@ -7,10 +7,10 @@ const models_1 = require("../models");
 var RetrySTTJobCommand;
 (function (RetrySTTJobCommand) {
     RetrySTTJobCommand.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        tokenReservationId: zod_1.z.uuid(),
         precalculatedPrice: zod_1.z.number(),
         mock: zod_1.z.boolean().optional(),
     });

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

@@ -2,9 +2,9 @@ import { z } from 'zod';
 import { USER_REACTION } from '../../common';
 export declare namespace SetReactionToSTTJobCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        uuid: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        uuid: z.ZodUUID;
         reaction: z.ZodNullable<z.ZodEnum<typeof USER_REACTION>>;
         dislikeReason: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>;

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

@@ -9,10 +9,10 @@ var SetReactionToSTTJobCommand;
 (function (SetReactionToSTTJobCommand) {
     SetReactionToSTTJobCommand.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(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        uuid: zod_1.z.uuid(),
+        reaction: zod_1.z.enum(common_1.USER_REACTION).nullable(),
         dislikeReason: zod_1.z.string().nullable().default(null),
     })
         .refine((data) => {

package/build/stt/commands/stt.command.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { JOB_SCOPE } from '../../common';
 export declare namespace STTCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>>;
         modelId: z.ZodString;
         fileId: z.ZodString;
@@ -11,7 +11,7 @@ export declare namespace STTCommand {
         fileUrl: z.ZodString;
         language: z.ZodOptional<z.ZodString>;
         durationInSeconds: z.ZodNumber;
-        tokenReservationId: z.ZodString;
+        tokenReservationId: z.ZodUUID;
         precalculatedPrice: z.ZodNumber;
         mock: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;

package/build/stt/commands/stt.command.js

@@ -8,16 +8,16 @@ const stt_job_schema_1 = require("../models/stt-job.schema");
 var STTCommand;
 (function (STTCommand) {
     STTCommand.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),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        scope: zod_1.z.enum(common_1.JOB_SCOPE).optional().default(common_1.JOB_SCOPE.TOOL),
         modelId: zod_1.z.string(),
         fileId: zod_1.z.string(),
         fileKey: zod_1.z.string(),
         fileUrl: zod_1.z.string(),
         language: zod_1.z.string().optional(),
         durationInSeconds: zod_1.z.number(),
-        tokenReservationId: zod_1.z.string().uuid(),
+        tokenReservationId: zod_1.z.uuid(),
         precalculatedPrice: zod_1.z.number(),
         mock: zod_1.z.boolean().optional(),
     });

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdateSTTJobFavoriteCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         isFavorite: z.ZodBoolean;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/stt/commands/update-stt-job-favorite.command.js

@@ -7,9 +7,9 @@ const stt_job_schema_1 = require("../models/stt-job.schema");
 var UpdateSTTJobFavoriteCommand;
 (function (UpdateSTTJobFavoriteCommand) {
     UpdateSTTJobFavoriteCommand.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         isFavorite: zod_1.z.boolean(),
     });
     UpdateSTTJobFavoriteCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(stt_job_schema_1.STTJobSchema);

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdateSTTJobTitleCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
         title: z.ZodString;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/stt/commands/update-stt-job-title.command.js

@@ -7,9 +7,9 @@ const stt_job_schema_1 = require("../models/stt-job.schema");
 var UpdateSTTJobTitleCommand;
 (function (UpdateSTTJobTitleCommand) {
     UpdateSTTJobTitleCommand.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
         title: zod_1.z.string().min(1).max(40),
     });
     UpdateSTTJobTitleCommand.RequestParamsSchema = zod_1.z.object({

package/build/stt/models/stt-config-with-vendors.schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const STTConfigWithVendorsSchema: z.ZodObject<{
     vendors: z.ZodArray<z.ZodObject<{
-        uuid: z.ZodString;
+        uuid: z.ZodUUID;
         title: z.ZodString;
         iconVariants: z.ZodObject<{
             light: z.ZodObject<{
@@ -41,7 +41,7 @@ export declare const STTConfigWithVendorsSchema: z.ZodObject<{
         maxSizeMB: z.ZodNumber;
         createdAt: z.ZodDate;
         updatedAt: z.ZodDate;
-        vendorId: z.ZodString;
+        vendorId: z.ZodUUID;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type STTConfigWithVendors = z.infer<typeof STTConfigWithVendorsSchema>;

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

@@ -14,9 +14,9 @@ exports.STTJobSchema = zod_1.z.object({
     fileUrl: zod_1.z.string(),
     language: zod_1.z.string().nullable().optional(),
     aiResponse: stt_response_schema_1.STTResponseSchema.nullable(),
-    reaction: zod_1.z.nativeEnum(common_1.USER_REACTION).nullable(),
+    reaction: zod_1.z.enum(common_1.USER_REACTION).nullable(),
     dislikeReason: zod_1.z.string().nullable(),
-    status: zod_1.z.nativeEnum(tools_1.JOB_STATUS),
+    status: zod_1.z.enum(tools_1.JOB_STATUS),
     duration: zod_1.z.number(),
     error: zod_1.z.string().nullable(),
     userId: zod_1.z.string().nullable(),

package/build/stt/models/stt-model-with-vendor.schema.d.ts

@@ -23,6 +23,6 @@ export declare const STTModelWithVendorSchema: z.ZodObject<{
     maxSizeMB: z.ZodNumber;
     createdAt: z.ZodDate;
     updatedAt: z.ZodDate;
-    vendorId: z.ZodString;
+    vendorId: z.ZodUUID;
 }, z.core.$strip>;
 export type STTModelWithVendor = z.infer<typeof STTModelWithVendorSchema>;

package/build/stt/models/stt-model-with-vendor.schema.js

@@ -4,5 +4,5 @@ exports.STTModelWithVendorSchema = void 0;
 const zod_1 = require("zod");
 const stt_model_schema_1 = require("./stt-model.schema");
 exports.STTModelWithVendorSchema = stt_model_schema_1.STTModelSchema.extend({
-    vendorId: zod_1.z.string().uuid(),
+    vendorId: zod_1.z.uuid(),
 });

package/build/stt/models/stt-model.schema.js

@@ -10,7 +10,7 @@ exports.STTModelSchema = zod_1.z.object({
     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),
+    status: zod_1.z.enum(common_1.TOOL_MODEL_STATUS),
     isHidden: zod_1.z.boolean(),
     icons: common_1.IconVariantsSchema,
     strategy: zod_1.z.string().optional(),

package/build/stt/queries/find-stt-job-by-uuid.query.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace FindSTTJobByUuidQuery {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/stt/queries/find-stt-job-by-uuid.query.js

@@ -7,9 +7,9 @@ const models_1 = require("../models");
 var FindSTTJobByUuidQuery;
 (function (FindSTTJobByUuidQuery) {
     FindSTTJobByUuidQuery.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
     });
     FindSTTJobByUuidQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.STTJobSchema);
 })(FindSTTJobByUuidQuery || (exports.FindSTTJobByUuidQuery = FindSTTJobByUuidQuery = {}));

package/build/stt/queries/find-stt-jobs.query.d.ts

@@ -3,8 +3,8 @@ import { JOB_SCOPE } from '../../common';
 import { JOB_SORT, JOB_STATUS } from '../../tools';
 export declare namespace FindSTTJobsQuery {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodString>;
-        unregisteredUserId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodUUID>;
+        unregisteredUserId: z.ZodOptional<z.ZodUUID>;
         scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<typeof JOB_SCOPE>>>;
         title: z.ZodOptional<z.ZodString>;
         isFavorite: z.ZodOptional<z.ZodCoercedBoolean<unknown>>;

package/build/stt/queries/find-stt-jobs.query.js

@@ -10,13 +10,13 @@ var FindSTTJobsQuery;
 (function (FindSTTJobsQuery) {
     FindSTTJobsQuery.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),
+        userId: zod_1.z.uuid().optional(),
+        unregisteredUserId: zod_1.z.uuid().optional(),
+        scope: zod_1.z.enum(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(),
+        createdAtSortOrder: zod_1.z.enum(tools_1.JOB_SORT).optional().default(tools_1.JOB_SORT.DESC),
+        status: zod_1.z.enum(tools_1.JOB_STATUS).optional(),
         limit: zod_1.z.coerce.number().min(1).optional(),
         offset: zod_1.z.coerce.number().min(0).optional(),
     })

package/build/tool-workspace/commands/soft-delete-all-tool-workspaces-by-tool-type.command.d.ts

@@ -3,8 +3,8 @@ import { TOOL_CONTENT_TYPE } from '../../tools/enums/tool-content-type.enum';
 export declare namespace SoftDeleteAllToolWorkspacesByToolTypeCommand {
     const RequestSchema: z.ZodObject<{
         toolType: z.ZodEnum<typeof TOOL_CONTENT_TYPE>;
-        userId: z.ZodOptional<z.ZodString>;
-        unregisteredUserId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodUUID>;
+        unregisteredUserId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/tool-workspace/commands/soft-delete-all-tool-workspaces-by-tool-type.command.js

@@ -8,9 +8,9 @@ var SoftDeleteAllToolWorkspacesByToolTypeCommand;
 (function (SoftDeleteAllToolWorkspacesByToolTypeCommand) {
     SoftDeleteAllToolWorkspacesByToolTypeCommand.RequestSchema = zod_1.z
         .object({
-        toolType: zod_1.z.nativeEnum(tool_content_type_enum_1.TOOL_CONTENT_TYPE),
-        userId: zod_1.z.string().uuid().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        toolType: zod_1.z.enum(tool_content_type_enum_1.TOOL_CONTENT_TYPE),
+        userId: zod_1.z.uuid().optional(),
+        unregisteredUserId: zod_1.z.uuid().optional(),
     })
         .refine((data) => {
         return Boolean(data.userId) !== Boolean(data.unregisteredUserId);

package/build/tool-workspace/commands/soft-delete-tool-workspace.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace SoftDeleteToolWorkspaceCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
-        userId: z.ZodOptional<z.ZodString>;
-        unregisteredUserId: z.ZodOptional<z.ZodString>;
+        uuid: z.ZodUUID;
+        userId: z.ZodOptional<z.ZodUUID>;
+        unregisteredUserId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/tool-workspace/commands/soft-delete-tool-workspace.command.js

@@ -7,9 +7,9 @@ var SoftDeleteToolWorkspaceCommand;
 (function (SoftDeleteToolWorkspaceCommand) {
     SoftDeleteToolWorkspaceCommand.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(),
+        uuid: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().optional(),
+        unregisteredUserId: zod_1.z.uuid().optional(),
     })
         .refine((data) => {
         return Boolean(data.userId) !== Boolean(data.unregisteredUserId);

package/build/tool-workspace/commands/update-tool-workspace.command.d.ts

@@ -2,12 +2,12 @@ import { z } from 'zod';
 import { TOOL_WORKSPACE_STATUS } from '../enums';
 export declare namespace UpdateToolWorkspaceCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
+        uuid: z.ZodUUID;
         title: z.ZodOptional<z.ZodString>;
         coverUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         status: z.ZodOptional<z.ZodEnum<typeof TOOL_WORKSPACE_STATUS>>;
-        userId: z.ZodOptional<z.ZodString>;
-        unregisteredUserId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodUUID>;
+        unregisteredUserId: z.ZodOptional<z.ZodUUID>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/tool-workspace/commands/update-tool-workspace.command.js

@@ -9,12 +9,12 @@ var UpdateToolWorkspaceCommand;
 (function (UpdateToolWorkspaceCommand) {
     UpdateToolWorkspaceCommand.RequestSchema = zod_1.z
         .object({
-        uuid: zod_1.z.string().uuid(),
+        uuid: zod_1.z.uuid(),
         title: zod_1.z.string().min(1).optional(),
         coverUrl: zod_1.z.string().nullable().optional(),
-        status: zod_1.z.nativeEnum(enums_1.TOOL_WORKSPACE_STATUS).optional(),
-        userId: zod_1.z.string().uuid().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().optional(),
+        status: zod_1.z.enum(enums_1.TOOL_WORKSPACE_STATUS).optional(),
+        userId: zod_1.z.uuid().optional(),
+        unregisteredUserId: zod_1.z.uuid().optional(),
     })
         .refine((data) => {
         return Boolean(data.userId) !== Boolean(data.unregisteredUserId);