@purpleschool/gptbot-tools 0.2.76 → 0.2.77

package/build/video-editor/models/video-editor-job.schema.d.ts

@@ -18,7 +18,7 @@ export declare const VideoEditorJobParamsSchema: z.ZodObject<{
     videoUrls: z.ZodOptional<z.ZodNever>;
     referenceImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
     referenceImageIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    audioUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    audioUrls: z.ZodOptional<z.ZodArray<z.ZodURL>>;
     audioIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     duration: z.ZodOptional<z.ZodNumber>;
     resolution: z.ZodOptional<z.ZodString>;
@@ -58,7 +58,7 @@ export declare const VideoEditorJobSchema: z.ZodObject<{
         videoUrls: z.ZodOptional<z.ZodNever>;
         referenceImages: z.ZodOptional<z.ZodArray<z.ZodString>>;
         referenceImageIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        audioUrls: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        audioUrls: z.ZodOptional<z.ZodArray<z.ZodURL>>;
         audioIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
         duration: z.ZodOptional<z.ZodNumber>;
         resolution: z.ZodOptional<z.ZodString>;

package/build/video-editor/models/video-editor-job.schema.js

@@ -11,7 +11,7 @@ exports.VideoEditorJobParamsSchema = zod_1.z.object({
     videoUrls: zod_1.z.never().optional(),
     referenceImages: zod_1.z.string().array().optional(),
     referenceImageIds: zod_1.z.array(zod_1.z.string()).optional(),
-    audioUrls: zod_1.z.array(zod_1.z.string().url()).optional(),
+    audioUrls: zod_1.z.array(zod_1.z.url()).optional(),
     audioIds: zod_1.z.array(zod_1.z.string()).optional(),
     duration: zod_1.z.number().optional(),
     resolution: zod_1.z.string().optional(),
@@ -21,10 +21,10 @@ exports.VideoEditorJobSchema = 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),
+    status: zod_1.z.enum(tools_1.JOB_STATUS),
     error: zod_1.z.string().nullable(),
     price: zod_1.z.number(),
-    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(),
     externalId: zod_1.z.string().nullable(),
     modelId: zod_1.z.string(),

package/build/video-editor/models/video-editor-model.schema.js

@@ -65,7 +65,7 @@ exports.VideoEditorModelPricingRuleConditionSchema = zod_1.z.object({
     aspectRatio: zod_1.z.string().optional(),
 });
 exports.VideoEditorModelPricingRulesSchema = zod_1.z.array(zod_1.z.object({
-    type: zod_1.z.nativeEnum(enums_1.VIDEO_EDITOR_PRICING_RULE_TYPE),
+    type: zod_1.z.enum(enums_1.VIDEO_EDITOR_PRICING_RULE_TYPE),
     condition: exports.VideoEditorModelPricingRuleConditionSchema,
     value: zod_1.z.number(),
 }));
@@ -75,9 +75,9 @@ exports.VideoEditorModelSchema = zod_1.z.object({
     description: zod_1.z.string(),
     aiModel: zod_1.z.string(),
     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),
     icons: common_1.IconVariantsSchema,
-    strategy: zod_1.z.nativeEnum(enums_1.VIDEO_EDITOR_MODEL_STRATEGY),
+    strategy: zod_1.z.enum(enums_1.VIDEO_EDITOR_MODEL_STRATEGY),
     maxPromptLength: zod_1.z.number(),
     maxInputVideoSizeBytes: zod_1.z.number(),
     maxInputVideoDurationInSeconds: zod_1.z.number(),
@@ -86,7 +86,7 @@ exports.VideoEditorModelSchema = zod_1.z.object({
     pricingRules: exports.VideoEditorModelPricingRulesSchema,
     needsTranslation: zod_1.z.boolean(),
     pricePerCall: zod_1.z.number(),
-    limitations: zod_1.z.array(zod_1.z.nativeEnum(enums_1.VIDEO_EDITOR_MODEL_LIMITATION)),
+    limitations: zod_1.z.array(zod_1.z.enum(enums_1.VIDEO_EDITOR_MODEL_LIMITATION)),
     createdAt: zod_1.z.date(),
     updatedAt: zod_1.z.date(),
 });

package/build/video-editor/queries/find-video-editor-job-by-id.query.d.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 export declare namespace FindVideoEditorJobByIdQuery {
     const RequestSchema: z.ZodObject<{
         uuid: z.ZodString;
-        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>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/video-editor/queries/find-video-editor-job-by-id.query.js

@@ -8,8 +8,8 @@ var FindVideoEditorJobByIdQuery;
 (function (FindVideoEditorJobByIdQuery) {
     FindVideoEditorJobByIdQuery.RequestSchema = zod_1.z.object({
         uuid: zod_1.z.string(),
-        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(),
     });
     FindVideoEditorJobByIdQuery.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(video_editor_job_schema_1.VideoEditorJobSchema);
 })(FindVideoEditorJobByIdQuery || (exports.FindVideoEditorJobByIdQuery = FindVideoEditorJobByIdQuery = {}));

package/build/video-editor/queries/find-video-editor-jobs.query.d.ts

@@ -3,8 +3,8 @@ import { JOB_SCOPE } from '../../common';
 import { JOB_SORT, JOB_STATUS } from '../../tools';
 export declare namespace FindVideoEditorJobsQuery {
     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/video-editor/queries/find-video-editor-jobs.query.js

@@ -10,13 +10,13 @@ var FindVideoEditorJobsQuery;
 (function (FindVideoEditorJobsQuery) {
     FindVideoEditorJobsQuery.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).default(0).optional(),
     })

package/build/writer/commands/collect-sources.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace CollectWriterDocumentSourcesCommand {
     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>>;
         mock: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/writer/commands/collect-sources.command.js

@@ -7,9 +7,9 @@ const models_1 = require("../models");
 var CollectWriterDocumentSourcesCommand;
 (function (CollectWriterDocumentSourcesCommand) {
     CollectWriterDocumentSourcesCommand.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(),
         mock: zod_1.z.boolean().optional(),
     });
     CollectWriterDocumentSourcesCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.WriterDocumentSchema);

package/build/writer/commands/confirm-source-citation-metadata.command.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace ConfirmSourceCitationMetadataCommand {
     const RequestSchema: z.ZodObject<{
-        documentId: z.ZodString;
-        sourceId: z.ZodString;
+        documentId: z.ZodUUID;
+        sourceId: z.ZodUUID;
         bibliographicMetadata: z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<import("..").WRITER_SOURCE_TYPE.BOOK>;
             title: z.ZodString;
@@ -20,8 +20,8 @@ export declare namespace ConfirmSourceCitationMetadataCommand {
             issueNumber: z.ZodString;
             pageRange: z.ZodString;
         }, z.core.$strip>], "type">;
-        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>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/writer/commands/confirm-source-citation-metadata.command.js

@@ -8,11 +8,11 @@ const writer_source_bibliographic_metadata_schema_1 = require("../models/writer-
 var ConfirmSourceCitationMetadataCommand;
 (function (ConfirmSourceCitationMetadataCommand) {
     ConfirmSourceCitationMetadataCommand.RequestSchema = zod_1.z.object({
-        documentId: zod_1.z.string().uuid(),
-        sourceId: zod_1.z.string().uuid(),
+        documentId: zod_1.z.uuid(),
+        sourceId: zod_1.z.uuid(),
         bibliographicMetadata: writer_source_bibliographic_metadata_schema_1.WriterSourceBibliographicMetadataSchema,
-        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(),
     });
     ConfirmSourceCitationMetadataCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(writer_source_schema_1.WriterSourceSchema);
 })(ConfirmSourceCitationMetadataCommand || (exports.ConfirmSourceCitationMetadataCommand = ConfirmSourceCitationMetadataCommand = {}));

package/build/writer/commands/create-writer-document.command.d.ts

@@ -3,11 +3,11 @@ import { LOCALE } from '@purpleschool/rugpt-lib-common';
 export declare namespace CreateWriterDocumentCommand {
     const RequestSchema: z.ZodObject<{
         locale: z.ZodDefault<z.ZodEnum<typeof LOCALE>>;
-        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>>;
         prompt: z.ZodString;
         numPages: z.ZodNumber;
-        documentTypeId: z.ZodString;
+        documentTypeId: z.ZodUUID;
         mock: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/writer/commands/create-writer-document.command.js

@@ -9,11 +9,11 @@ var CreateWriterDocumentCommand;
 (function (CreateWriterDocumentCommand) {
     CreateWriterDocumentCommand.RequestSchema = zod_1.z.object({
         locale: common_1.LocaleSchema.default(rugpt_lib_common_1.LOCALE.RU),
-        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(),
         prompt: zod_1.z.string(),
         numPages: zod_1.z.number(),
-        documentTypeId: zod_1.z.string().uuid(),
+        documentTypeId: zod_1.z.uuid(),
         mock: zod_1.z.boolean().optional(),
     });
     CreateWriterDocumentCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.WriterDocumentSchema);

package/build/writer/commands/delete-all-user-writer-documents.command.d.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace DeleteAllUserWriterDocumentsCommandContract {
     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>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/writer/commands/delete-all-user-writer-documents.command.js

@@ -7,8 +7,8 @@ var DeleteAllUserWriterDocumentsCommandContract;
 (function (DeleteAllUserWriterDocumentsCommandContract) {
     DeleteAllUserWriterDocumentsCommandContract.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(),
     })
         .refine((v) => !!v.userId !== !!v.unregisteredUserId, {
         message: 'Provide either userId or unregisteredUserId',

package/build/writer/commands/delete-writer-document.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace DeleteWriterDocumentCommandContract {
     const RequestSchema: z.ZodObject<{
-        documentId: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        documentId: 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/writer/commands/delete-writer-document.command.js

@@ -6,9 +6,9 @@ const common_1 = require("../../common");
 var DeleteWriterDocumentCommandContract;
 (function (DeleteWriterDocumentCommandContract) {
     DeleteWriterDocumentCommandContract.RequestSchema = zod_1.z.object({
-        documentId: zod_1.z.string().uuid(),
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
+        documentId: zod_1.z.uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
     });
     DeleteWriterDocumentCommandContract.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.boolean());
 })(DeleteWriterDocumentCommandContract || (exports.DeleteWriterDocumentCommandContract = DeleteWriterDocumentCommandContract = {}));

package/build/writer/commands/discard-writer-source.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace DiscardWriterSourceCommand {
     const RequestSchema: z.ZodObject<{
-        sourceId: z.ZodString;
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        sourceId: 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/writer/commands/discard-writer-source.command.js

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

package/build/writer/commands/export-writer-document-as-docx.command.d.ts

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

package/build/writer/commands/export-writer-document-as-docx.command.js

@@ -6,11 +6,11 @@ const common_1 = require("../../common");
 var ExportWriterDocumentAsDocxCommand;
 (function (ExportWriterDocumentAsDocxCommand) {
     ExportWriterDocumentAsDocxCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        documentId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        documentId: zod_1.z.uuid(),
     });
     ExportWriterDocumentAsDocxCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.object({
-        url: zod_1.z.string().url(),
+        url: zod_1.z.url(),
     }));
 })(ExportWriterDocumentAsDocxCommand || (exports.ExportWriterDocumentAsDocxCommand = ExportWriterDocumentAsDocxCommand = {}));

package/build/writer/commands/generate-document-contents.command.d.ts

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

package/build/writer/commands/generate-document-contents.command.js

@@ -7,10 +7,10 @@ const models_1 = require("../models");
 var GenerateWriterDocumentContentsCommand;
 (function (GenerateWriterDocumentContentsCommand) {
     GenerateWriterDocumentContentsCommand.RequestSchema = zod_1.z.object({
-        documentId: 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(),
+        documentId: 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(),
         modelId: zod_1.z.string(),
         mock: zod_1.z.boolean().optional(),

package/build/writer/commands/generate-document-outline.command.d.ts

@@ -1,12 +1,12 @@
 import { z } from 'zod';
 export declare namespace GenerateWriterDocumentOutlineCommand {
     const RequestSchema: z.ZodObject<{
-        uuid: z.ZodString;
+        uuid: z.ZodUUID;
         locale: z.ZodEnum<typeof import("@purpleschool/rugpt-lib-common").LOCALE>;
         numPages: z.ZodNumber;
         description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        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>>;
         mock: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;

package/build/writer/commands/generate-document-outline.command.js

@@ -8,12 +8,12 @@ const models_1 = require("../models");
 var GenerateWriterDocumentOutlineCommand;
 (function (GenerateWriterDocumentOutlineCommand) {
     GenerateWriterDocumentOutlineCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+        uuid: zod_1.z.uuid(),
         locale: locale_schema_1.LocaleSchema,
         numPages: zod_1.z.number(),
         description: zod_1.z.string().nullable().optional(),
-        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(),
         mock: zod_1.z.boolean().optional(),
     });
     GenerateWriterDocumentOutlineCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.WriterDocumentSchema);

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

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 export declare namespace GetWriterContentGenerationPriceCommand {
     const RequestSchema: z.ZodObject<{
-        documentId: z.ZodString;
-        modelId: z.ZodString;
+        documentId: z.ZodUUID;
+        modelId: z.ZodUUID;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseDataSchema: z.ZodObject<{

package/build/writer/commands/get-writer-content-generation-price.command.js

@@ -6,8 +6,8 @@ const common_1 = require("../../common");
 var GetWriterContentGenerationPriceCommand;
 (function (GetWriterContentGenerationPriceCommand) {
     GetWriterContentGenerationPriceCommand.RequestSchema = zod_1.z.object({
-        documentId: zod_1.z.string().uuid(),
-        modelId: zod_1.z.string().uuid(),
+        documentId: zod_1.z.uuid(),
+        modelId: zod_1.z.uuid(),
     });
     GetWriterContentGenerationPriceCommand.ResponseDataSchema = zod_1.z.object({
         price: zod_1.z.number(),

package/build/writer/commands/set-reaction-writer-document.command.d.ts

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

package/build/writer/commands/set-reaction-writer-document.command.js

@@ -8,10 +8,10 @@ var SetReactionToWriterDocumentCommand;
 (function (SetReactionToWriterDocumentCommand) {
     SetReactionToWriterDocumentCommand.RequestSchema = zod_1.z
         .object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        documentId: zod_1.z.string().uuid(),
-        reaction: zod_1.z.nativeEnum(common_1.USER_REACTION),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        documentId: zod_1.z.uuid(),
+        reaction: zod_1.z.enum(common_1.USER_REACTION),
         dislikeReason: zod_1.z.string().nullable().default(null),
     })
         .refine((data) => {

package/build/writer/commands/toggle-writer-document-title-page.command.d.ts

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

package/build/writer/commands/toggle-writer-document-title-page.command.js

@@ -6,9 +6,9 @@ const common_1 = require("../../common");
 var ToggleWriterDocumentTitlePageCommand;
 (function (ToggleWriterDocumentTitlePageCommand) {
     ToggleWriterDocumentTitlePageCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        documentId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        documentId: zod_1.z.uuid(),
         enabled: zod_1.z.boolean(),
     });
     ToggleWriterDocumentTitlePageCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.object({

package/build/writer/commands/update-writer-document-contents.command.d.ts

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

package/build/writer/commands/update-writer-document-contents.command.js

@@ -6,9 +6,9 @@ const common_1 = require("../../common");
 var UpdateWriterDocumentContentsCommand;
 (function (UpdateWriterDocumentContentsCommand) {
     UpdateWriterDocumentContentsCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        documentId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        documentId: zod_1.z.uuid(),
         contents: zod_1.z.string(),
     });
     UpdateWriterDocumentContentsCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.object({

package/build/writer/commands/update-writer-document-favorite.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdateWriterDocumentFavoriteCommand {
     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/writer/commands/update-writer-document-favorite.command.js

@@ -7,9 +7,9 @@ const models_1 = require("../models");
 var UpdateWriterDocumentFavoriteCommand;
 (function (UpdateWriterDocumentFavoriteCommand) {
     UpdateWriterDocumentFavoriteCommand.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(),
     });
     UpdateWriterDocumentFavoriteCommand.ResponseSchema = (0, command_response_schema_1.ICommandResponseSchema)(models_1.WriterDocumentSchema);

package/build/writer/commands/update-writer-document-final-md.command.d.ts

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

package/build/writer/commands/update-writer-document-final-md.command.js

@@ -6,9 +6,9 @@ const common_1 = require("../../common");
 var UpdateWriterDocumentContentsCommand;
 (function (UpdateWriterDocumentContentsCommand) {
     UpdateWriterDocumentContentsCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        documentId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        documentId: zod_1.z.uuid(),
         contents: zod_1.z.string(),
     });
     UpdateWriterDocumentContentsCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(zod_1.z.object({

package/build/writer/commands/update-writer-document-outline.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 export declare namespace UpdateWriterDocumentOutlineCommand {
     const RequestSchema: z.ZodObject<{
-        userId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        documentId: z.ZodString;
+        userId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        unregisteredUserId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+        documentId: z.ZodUUID;
         data: z.ZodArray<z.ZodObject<{
             title: z.ZodString;
             type: z.ZodEnum<typeof import("..").WRITER_DOCUMENT_SECTION_TYPE>;
@@ -11,7 +11,7 @@ export declare namespace UpdateWriterDocumentOutlineCommand {
                 title: z.ZodString;
             }, z.core.$strip>>>>;
         }, z.core.$strip>>;
-        modelId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        modelId: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
     }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{

package/build/writer/commands/update-writer-document-outline.command.js

@@ -7,11 +7,11 @@ const models_1 = require("../models");
 var UpdateWriterDocumentOutlineCommand;
 (function (UpdateWriterDocumentOutlineCommand) {
     UpdateWriterDocumentOutlineCommand.RequestSchema = zod_1.z.object({
-        userId: zod_1.z.string().uuid().nullable().optional(),
-        unregisteredUserId: zod_1.z.string().uuid().nullable().optional(),
-        documentId: zod_1.z.string().uuid(),
+        userId: zod_1.z.uuid().nullable().optional(),
+        unregisteredUserId: zod_1.z.uuid().nullable().optional(),
+        documentId: zod_1.z.uuid(),
         data: models_1.WriterDocumentOutlineSchema,
-        modelId: zod_1.z.string().uuid().nullable().optional(),
+        modelId: zod_1.z.uuid().nullable().optional(),
     });
     UpdateWriterDocumentOutlineCommand.ResponseSchema = (0, common_1.ICommandResponseSchema)(models_1.WriterDocumentOutlineSchema);
 })(UpdateWriterDocumentOutlineCommand || (exports.UpdateWriterDocumentOutlineCommand = UpdateWriterDocumentOutlineCommand = {}));