@veruna/api-contracts 1.0.46 → 1.0.47

package/build/v1/message/schemas/message-meta.schema.d.ts

@@ -1,12 +1,16 @@
 import { z } from 'zod';
 /**
  * Reasoning detail from AI model (e.g., Claude extended thinking)
+ * Supports both plain text and encrypted reasoning formats
  */
 export declare const ReasoningDetailSchema: z.ZodObject<{
     type: z.ZodString;
-    text: z.ZodString;
+    text: z.ZodOptional<z.ZodString>;
     format: z.ZodOptional<z.ZodString>;
     index: z.ZodOptional<z.ZodNumber>;
+    id: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * Reasoning metadata - model's thinking process
@@ -15,9 +19,12 @@ export declare const ReasoningMetaSchema: z.ZodObject<{
     content: z.ZodString;
     details: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodString;
-        text: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
         index: z.ZodOptional<z.ZodNumber>;
+        id: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 /**
@@ -28,9 +35,12 @@ export declare const MessageMetaSchema: z.ZodObject<{
         content: z.ZodString;
         details: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodString;
-            text: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
             format: z.ZodOptional<z.ZodString>;
             index: z.ZodOptional<z.ZodNumber>;
+            id: z.ZodOptional<z.ZodString>;
+            data: z.ZodOptional<z.ZodString>;
+            summary: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;

package/build/v1/message/schemas/message-meta.schema.js

@@ -4,12 +4,18 @@ exports.MessageMetaSchema = exports.ReasoningMetaSchema = exports.ReasoningDetai
 const zod_1 = require("zod");
 /**
  * Reasoning detail from AI model (e.g., Claude extended thinking)
+ * Supports both plain text and encrypted reasoning formats
  */
 exports.ReasoningDetailSchema = zod_1.z.object({
     type: zod_1.z.string(),
-    text: zod_1.z.string(),
+    /** Plain text reasoning (for non-encrypted) */
+    text: zod_1.z.string().optional(),
     format: zod_1.z.string().optional(),
     index: zod_1.z.number().int().nonnegative().optional(),
+    /** Encrypted reasoning fields (OpenAI responses format) */
+    id: zod_1.z.string().optional(),
+    data: zod_1.z.string().optional(),
+    summary: zod_1.z.string().optional(),
 });
 /**
  * Reasoning metadata - model's thinking process

package/build/v1/message/schemas/message-response.schema.d.ts

@@ -14,9 +14,12 @@ export declare const MessageResponseSchema: z.ZodObject<{
             content: z.ZodString;
             details: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 type: z.ZodString;
-                text: z.ZodString;
+                text: z.ZodOptional<z.ZodString>;
                 format: z.ZodOptional<z.ZodString>;
                 index: z.ZodOptional<z.ZodNumber>;
+                id: z.ZodOptional<z.ZodString>;
+                data: z.ZodOptional<z.ZodString>;
+                summary: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;

package/build/v1/message/schemas/rate-message.schema.d.ts

@@ -1,11 +1,19 @@
 import { z } from 'zod';
 import { UserRating } from './user-rating.enum';
+/**
+ * Rate Message Request Schema
+ * Error messages: RateMessageRequest.{field}.{rule}
+ */
 export declare const RateMessageRequestSchema: z.ZodObject<{
     rating: z.ZodEnum<typeof UserRating>;
 }, z.core.$strip>;
 export declare const RateMessageResponseSchema: z.ZodObject<{
     id: z.ZodString;
 }, z.core.$strip>;
+/**
+ * Rate Message Params Schema
+ * Error messages: RateMessageParams.{field}.{rule}
+ */
 export declare const RateMessageParamsSchema: z.ZodObject<{
     pageId: z.ZodString;
     chatId: z.ZodString;

package/build/v1/message/schemas/rate-message.schema.js

@@ -3,14 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RateMessageParamsSchema = exports.RateMessageResponseSchema = exports.RateMessageRequestSchema = void 0;
 const zod_1 = require("zod");
 const user_rating_enum_1 = require("./user-rating.enum");
+/**
+ * Rate Message Request Schema
+ * Error messages: RateMessageRequest.{field}.{rule}
+ */
 exports.RateMessageRequestSchema = zod_1.z.object({
-    rating: zod_1.z.nativeEnum(user_rating_enum_1.UserRating),
+    rating: zod_1.z.nativeEnum(user_rating_enum_1.UserRating, {
+        error: 'RateMessageRequest.rating.invalid',
+    }),
 });
 exports.RateMessageResponseSchema = zod_1.z.object({
     id: zod_1.z.string().uuid(),
 });
+/**
+ * Rate Message Params Schema
+ * Error messages: RateMessageParams.{field}.{rule}
+ */
 exports.RateMessageParamsSchema = zod_1.z.object({
-    pageId: zod_1.z.string().uuid(),
-    chatId: zod_1.z.string().uuid(),
-    messageId: zod_1.z.string().uuid(),
+    pageId: zod_1.z
+        .string({ error: 'RateMessageParams.pageId.required' })
+        .uuid({ message: 'RateMessageParams.pageId.invalid' }),
+    chatId: zod_1.z
+        .string({ error: 'RateMessageParams.chatId.required' })
+        .uuid({ message: 'RateMessageParams.chatId.invalid' }),
+    messageId: zod_1.z
+        .string({ error: 'RateMessageParams.messageId.required' })
+        .uuid({ message: 'RateMessageParams.messageId.invalid' }),
 });

package/build/v1/message/schemas/stream-events.schema.d.ts

@@ -36,9 +36,12 @@ export declare const StreamReasoningEventSchema: z.ZodObject<{
     reasoning: z.ZodString;
     reasoningDetails: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodString;
-        text: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
         index: z.ZodOptional<z.ZodNumber>;
+        id: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 /**
@@ -93,9 +96,12 @@ export declare const StreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     reasoning: z.ZodString;
     reasoningDetails: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodString;
-        text: z.ZodString;
+        text: z.ZodOptional<z.ZodString>;
         format: z.ZodOptional<z.ZodString>;
         index: z.ZodOptional<z.ZodNumber>;
+        id: z.ZodOptional<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>, z.ZodObject<{
     id: z.ZodNumber;

package/build/v1/message/schemas/stream-events.schema.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamEventSchema = exports.StreamImageEventSchema = exports.StreamErrorEventSchema = exports.StreamDoneEventSchema = exports.StreamReasoningEventSchema = exports.StreamChunkEventSchema = exports.StreamEventType = void 0;
 const zod_1 = require("zod");
+const message_meta_schema_1 = require("./message-meta.schema");
 /**
  * Stream Event Types for message streaming (NDJSON format)
  */
@@ -48,15 +49,9 @@ exports.StreamReasoningEventSchema = BaseStreamEventSchema.extend({
     /** Always empty for reasoning event */
     content: zod_1.z.literal(''),
     /** Partial reasoning text */
-    reasoning: zod_1.z.string().min(1),
-    reasoningDetails: zod_1.z
-        .array(zod_1.z.object({
-        type: zod_1.z.string(),
-        text: zod_1.z.string(),
-        format: zod_1.z.string().optional(),
-        index: zod_1.z.number().int().nonnegative().optional(),
-    }))
-        .optional(),
+    reasoning: zod_1.z.string(),
+    /** Structured reasoning details (plain or encrypted) */
+    reasoningDetails: zod_1.z.array(message_meta_schema_1.ReasoningDetailSchema).optional(),
 });
 /**
  * Done event - stream completed successfully

package/build/v1/page-hints/schemas/create-hint-request.schema.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 /**
  * Create Page Hint Request Schema
+ * Error messages: CreateHintRequest.{field}.{rule}
  */
 export declare const CreateHintRequestSchema: z.ZodObject<{
     icon: z.ZodString;

package/build/v1/page-hints/schemas/create-hint-request.schema.js

@@ -4,8 +4,15 @@ exports.CreateHintRequestSchema = void 0;
 const zod_1 = require("zod");
 /**
  * Create Page Hint Request Schema
+ * Error messages: CreateHintRequest.{field}.{rule}
  */
 exports.CreateHintRequestSchema = zod_1.z.object({
-    icon: zod_1.z.string().min(1).max(50),
-    title: zod_1.z.string().min(1).max(255),
+    icon: zod_1.z
+        .string({ error: 'CreateHintRequest.icon.required' })
+        .min(1, { message: 'CreateHintRequest.icon.min' })
+        .max(50, { message: 'CreateHintRequest.icon.max' }),
+    title: zod_1.z
+        .string({ error: 'CreateHintRequest.title.required' })
+        .min(1, { message: 'CreateHintRequest.title.min' })
+        .max(255, { message: 'CreateHintRequest.title.max' }),
 });

package/build/v1/page-hints/schemas/update-hint-request.schema.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 /**
  * Update Page Hint Request Schema
+ * Error messages: UpdateHintRequest.{field}.{rule}
  */
 export declare const UpdateHintRequestSchema: z.ZodObject<{
     icon: z.ZodOptional<z.ZodString>;

package/build/v1/page-hints/schemas/update-hint-request.schema.js

@@ -4,8 +4,17 @@ exports.UpdateHintRequestSchema = void 0;
 const zod_1 = require("zod");
 /**
  * Update Page Hint Request Schema
+ * Error messages: UpdateHintRequest.{field}.{rule}
  */
 exports.UpdateHintRequestSchema = zod_1.z.object({
-    icon: zod_1.z.string().min(1).max(50).optional(),
-    title: zod_1.z.string().min(1).max(255).optional(),
+    icon: zod_1.z
+        .string()
+        .min(1, { message: 'UpdateHintRequest.icon.min' })
+        .max(50, { message: 'UpdateHintRequest.icon.max' })
+        .optional(),
+    title: zod_1.z
+        .string()
+        .min(1, { message: 'UpdateHintRequest.title.min' })
+        .max(255, { message: 'UpdateHintRequest.title.max' })
+        .optional(),
 });

package/build/v1/seo-pages/schemas/create-page-request.schema.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { PageType } from './page-type.enum';
 /**
  * Create SEO Page Request Schema
+ * Error messages: CreatePageRequest.{field}.{rule}
  */
 export declare const CreatePageRequestSchema: z.ZodObject<{
     metaTitle: z.ZodString;

package/build/v1/seo-pages/schemas/create-page-request.schema.js

@@ -7,26 +7,53 @@ const page_type_enum_1 = require("./page-type.enum");
 const faq_schema_1 = require("./faq.schema");
 /**
  * Create SEO Page Request Schema
+ * Error messages: CreatePageRequest.{field}.{rule}
  */
 exports.CreatePageRequestSchema = zod_1.z.object({
-    metaTitle: zod_1.z.string().min(1).max(100),
-    metaDescription: zod_1.z.string().min(1).max(200),
-    title: zod_1.z.string().min(1).max(300),
-    description: zod_1.z.string().min(1),
-    content: zod_1.z.string().min(1),
+    metaTitle: zod_1.z
+        .string({ error: 'CreatePageRequest.metaTitle.required' })
+        .min(1, { message: 'CreatePageRequest.metaTitle.min' })
+        .max(100, { message: 'CreatePageRequest.metaTitle.max' }),
+    metaDescription: zod_1.z
+        .string({ error: 'CreatePageRequest.metaDescription.required' })
+        .min(1, { message: 'CreatePageRequest.metaDescription.min' })
+        .max(200, { message: 'CreatePageRequest.metaDescription.max' }),
+    title: zod_1.z
+        .string({ error: 'CreatePageRequest.title.required' })
+        .min(1, { message: 'CreatePageRequest.title.min' })
+        .max(300, { message: 'CreatePageRequest.title.max' }),
+    description: zod_1.z
+        .string({ error: 'CreatePageRequest.description.required' })
+        .min(1, { message: 'CreatePageRequest.description.min' }),
+    content: zod_1.z
+        .string({ error: 'CreatePageRequest.content.required' })
+        .min(1, { message: 'CreatePageRequest.content.min' }),
     alias: zod_1.z
-        .string()
-        .min(1)
-        .max(200)
-        .regex(shared_1.SLUG_REGEX)
+        .string({ error: 'CreatePageRequest.alias.required' })
+        .min(1, { message: 'CreatePageRequest.alias.min' })
+        .max(200, { message: 'CreatePageRequest.alias.max' })
+        .regex(shared_1.SLUG_REGEX, { message: 'CreatePageRequest.alias.invalid' })
         .transform((val) => val.toLowerCase().trim()),
-    type: zod_1.z.enum(page_type_enum_1.PageType),
-    icon: zod_1.z.string().min(1).max(100),
+    type: zod_1.z.enum(page_type_enum_1.PageType, {
+        error: 'CreatePageRequest.type.invalid',
+    }),
+    icon: zod_1.z
+        .string({ error: 'CreatePageRequest.icon.required' })
+        .min(1, { message: 'CreatePageRequest.icon.min' })
+        .max(100, { message: 'CreatePageRequest.icon.max' }),
     faq: faq_schema_1.FaqSchema.optional(),
     // Hierarchy & additional fields
-    parentId: zod_1.z.string().regex(shared_1.UUID_REGEX).nullable().optional(),
-    order: zod_1.z.number().int().min(0).default(0),
-    placeholder: zod_1.z.string().max(500).nullable().optional(),
-    seoName: zod_1.z.string().max(200).nullable().optional(),
-    marks: zod_1.z.array(zod_1.z.string().max(50)).default([]),
+    parentId: zod_1.z
+        .string()
+        .regex(shared_1.UUID_REGEX, { message: 'CreatePageRequest.parentId.invalid' })
+        .nullable()
+        .optional(),
+    order: zod_1.z
+        .number()
+        .int({ message: 'CreatePageRequest.order.invalid' })
+        .min(0, { message: 'CreatePageRequest.order.invalid' })
+        .default(0),
+    placeholder: zod_1.z.string().max(500, { message: 'CreatePageRequest.placeholder.max' }).nullable().optional(),
+    seoName: zod_1.z.string().max(200, { message: 'CreatePageRequest.seoName.max' }).nullable().optional(),
+    marks: zod_1.z.array(zod_1.z.string().max(50, { message: 'CreatePageRequest.marks.max' })).default([]),
 });

package/build/v1/seo-pages/schemas/faq.schema.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 /**
  * FAQ Item Schema
+ * Error messages: FaqItem.{field}.{rule}
  */
 export declare const FaqItemSchema: z.ZodObject<{
     question: z.ZodString;
@@ -8,6 +9,7 @@ export declare const FaqItemSchema: z.ZodObject<{
 }, z.core.$strip>;
 /**
  * FAQ Schema
+ * Error messages: Faq.{field}.{rule}
  */
 export declare const FaqSchema: z.ZodObject<{
     items: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/build/v1/seo-pages/schemas/faq.schema.js

@@ -4,14 +4,22 @@ exports.FaqSchema = exports.FaqItemSchema = void 0;
 const zod_1 = require("zod");
 /**
  * FAQ Item Schema
+ * Error messages: FaqItem.{field}.{rule}
  */
 exports.FaqItemSchema = zod_1.z.object({
-    question: zod_1.z.string().min(10).max(500),
-    answer: zod_1.z.string().min(20).max(2000),
+    question: zod_1.z
+        .string({ error: 'FaqItem.question.required' })
+        .min(10, { message: 'FaqItem.question.min' })
+        .max(500, { message: 'FaqItem.question.max' }),
+    answer: zod_1.z
+        .string({ error: 'FaqItem.answer.required' })
+        .min(20, { message: 'FaqItem.answer.min' })
+        .max(2000, { message: 'FaqItem.answer.max' }),
 });
 /**
  * FAQ Schema
+ * Error messages: Faq.{field}.{rule}
  */
 exports.FaqSchema = zod_1.z.object({
-    items: zod_1.z.array(exports.FaqItemSchema).max(20).default([]),
+    items: zod_1.z.array(exports.FaqItemSchema).max(20, { message: 'Faq.items.max' }).default([]),
 });

package/build/v1/seo-pages/schemas/update-page-request.schema.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { PageType } from './page-type.enum';
 /**
  * Update SEO Page Request Schema
+ * Error messages: UpdatePageRequest.{field}.{rule}
  */
 export declare const UpdatePageRequestSchema: z.ZodObject<{
     metaTitle: z.ZodOptional<z.ZodString>;

package/build/v1/seo-pages/schemas/update-page-request.schema.js

@@ -7,27 +7,52 @@ const page_type_enum_1 = require("./page-type.enum");
 const faq_schema_1 = require("./faq.schema");
 /**
  * Update SEO Page Request Schema
+ * Error messages: UpdatePageRequest.{field}.{rule}
  */
 exports.UpdatePageRequestSchema = zod_1.z.object({
-    metaTitle: zod_1.z.string().min(1).max(100).optional(),
-    metaDescription: zod_1.z.string().min(1).max(200).optional(),
-    title: zod_1.z.string().min(1).max(300).optional(),
-    description: zod_1.z.string().min(1).optional(),
-    content: zod_1.z.string().min(1).optional(),
+    metaTitle: zod_1.z
+        .string()
+        .min(1, { message: 'UpdatePageRequest.metaTitle.min' })
+        .max(100, { message: 'UpdatePageRequest.metaTitle.max' })
+        .optional(),
+    metaDescription: zod_1.z
+        .string()
+        .min(1, { message: 'UpdatePageRequest.metaDescription.min' })
+        .max(200, { message: 'UpdatePageRequest.metaDescription.max' })
+        .optional(),
+    title: zod_1.z
+        .string()
+        .min(1, { message: 'UpdatePageRequest.title.min' })
+        .max(300, { message: 'UpdatePageRequest.title.max' })
+        .optional(),
+    description: zod_1.z.string().min(1, { message: 'UpdatePageRequest.description.min' }).optional(),
+    content: zod_1.z.string().min(1, { message: 'UpdatePageRequest.content.min' }).optional(),
     alias: zod_1.z
         .string()
-        .min(1)
-        .max(200)
-        .regex(shared_1.SLUG_REGEX)
+        .min(1, { message: 'UpdatePageRequest.alias.min' })
+        .max(200, { message: 'UpdatePageRequest.alias.max' })
+        .regex(shared_1.SLUG_REGEX, { message: 'UpdatePageRequest.alias.invalid' })
         .transform((val) => val.toLowerCase().trim())
         .optional(),
-    type: zod_1.z.enum(page_type_enum_1.PageType).optional(),
-    icon: zod_1.z.string().min(1).max(100).optional(),
+    type: zod_1.z.enum(page_type_enum_1.PageType, { error: 'UpdatePageRequest.type.invalid' }).optional(),
+    icon: zod_1.z
+        .string()
+        .min(1, { message: 'UpdatePageRequest.icon.min' })
+        .max(100, { message: 'UpdatePageRequest.icon.max' })
+        .optional(),
     faq: faq_schema_1.FaqSchema.optional(),
     // Hierarchy & additional fields
-    parentId: zod_1.z.string().regex(shared_1.UUID_REGEX).nullable().optional(),
-    order: zod_1.z.number().int().min(0).optional(),
-    placeholder: zod_1.z.string().max(500).nullable().optional(),
-    seoName: zod_1.z.string().max(200).nullable().optional(),
-    marks: zod_1.z.array(zod_1.z.string().max(50)).optional(),
+    parentId: zod_1.z
+        .string()
+        .regex(shared_1.UUID_REGEX, { message: 'UpdatePageRequest.parentId.invalid' })
+        .nullable()
+        .optional(),
+    order: zod_1.z
+        .number()
+        .int({ message: 'UpdatePageRequest.order.invalid' })
+        .min(0, { message: 'UpdatePageRequest.order.invalid' })
+        .optional(),
+    placeholder: zod_1.z.string().max(500, { message: 'UpdatePageRequest.placeholder.max' }).nullable().optional(),
+    seoName: zod_1.z.string().max(200, { message: 'UpdatePageRequest.seoName.max' }).nullable().optional(),
+    marks: zod_1.z.array(zod_1.z.string().max(50, { message: 'UpdatePageRequest.marks.max' })).optional(),
 });

package/build/v1/unregistered-users/schemas/authenticate-request.schema.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 /**
  * UTM Schema
+ * Error messages: UtmSchema.{field}.{rule}
  */
 export declare const UtmSchema: z.ZodObject<{
     utmSource: z.ZodOptional<z.ZodString>;
@@ -11,6 +12,7 @@ export declare const UtmSchema: z.ZodObject<{
 }, z.core.$strip>;
 /**
  * Authenticate Unregistered User Request Schema
+ * Error messages: AuthenticateUnregUserRequest.{field}.{rule}
  */
 export declare const AuthenticateUnregUserRequestSchema: z.ZodObject<{
     token: z.ZodOptional<z.ZodString>;

package/build/v1/unregistered-users/schemas/authenticate-request.schema.js

@@ -4,18 +4,20 @@ exports.AuthenticateUnregUserRequestSchema = exports.UtmSchema = void 0;
 const zod_1 = require("zod");
 /**
  * UTM Schema
+ * Error messages: UtmSchema.{field}.{rule}
  */
 exports.UtmSchema = zod_1.z.object({
-    utmSource: zod_1.z.string().optional(),
-    utmMedium: zod_1.z.string().optional(),
-    utmCampaign: zod_1.z.string().optional(),
+    utmSource: zod_1.z.string({ error: 'UtmSchema.utmSource.invalid' }).optional(),
+    utmMedium: zod_1.z.string({ error: 'UtmSchema.utmMedium.invalid' }).optional(),
+    utmCampaign: zod_1.z.string({ error: 'UtmSchema.utmCampaign.invalid' }).optional(),
     utmContent: zod_1.z.string().optional(),
     utmTerm: zod_1.z.string().optional(),
 });
 /**
  * Authenticate Unregistered User Request Schema
+ * Error messages: AuthenticateUnregUserRequest.{field}.{rule}
  */
 exports.AuthenticateUnregUserRequestSchema = zod_1.z.object({
-    token: zod_1.z.string().optional(),
+    token: zod_1.z.string({ error: 'AuthenticateUnregUserRequest.token.invalid' }).optional(),
     utm: exports.UtmSchema.optional(),
 });

package/build/v1/users/commands/email-change-start.command.d.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { HttpMethod } from '../../../shared/http-method';
 export declare namespace UserEmailChangeStartCommand {
     const Request: z.ZodObject<{
-        newEmail: z.ZodEmail;
+        newEmail: z.ZodString;
     }, z.core.$strip>;
     const Response: z.ZodObject<{
         requestId: z.ZodString;

package/build/v1/users/schemas/change-password-request.schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 /**
  * Change Password Request Schema
- * Error messages are in locales (en.ts, ru.ts)
+ * Error messages: ChangePasswordRequest.{field}.{rule}
  */
 export declare const ChangePasswordRequestSchema: z.ZodObject<{
     oldPassword: z.ZodString;

package/build/v1/users/schemas/change-password-request.schema.js

@@ -5,10 +5,16 @@ const zod_1 = require("zod");
 const regex_1 = require("../../../shared/regex");
 /**
  * Change Password Request Schema
- * Error messages are in locales (en.ts, ru.ts)
+ * Error messages: ChangePasswordRequest.{field}.{rule}
  */
 exports.ChangePasswordRequestSchema = zod_1.z.object({
-    oldPassword: zod_1.z.string().min(1),
-    newPassword: zod_1.z.string().min(8).max(128).regex(regex_1.PASSWORD_STRENGTH_REGEX),
+    oldPassword: zod_1.z
+        .string({ error: 'ChangePasswordRequest.oldPassword.required' })
+        .min(1, { message: 'ChangePasswordRequest.oldPassword.min' }),
+    newPassword: zod_1.z
+        .string({ error: 'ChangePasswordRequest.newPassword.required' })
+        .min(8, { message: 'ChangePasswordRequest.newPassword.min' })
+        .max(128, { message: 'ChangePasswordRequest.newPassword.max' })
+        .regex(regex_1.PASSWORD_STRENGTH_REGEX, { message: 'ChangePasswordRequest.newPassword.weak' }),
     logoutFromAllDevices: zod_1.z.boolean().default(false),
 });

package/build/v1/users/schemas/delete-account-start-request.schema.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+/**
+ * Delete Account Start Request Schema
+ * Error messages: DeleteAccountStartRequest.{field}.{rule}
+ */
 export declare const DeleteAccountStartRequestSchema: z.ZodObject<{
     password: z.ZodString;
 }, z.core.$strip>;

package/build/v1/users/schemas/delete-account-start-request.schema.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleteAccountStartRequestSchema = void 0;
 const zod_1 = require("zod");
+/**
+ * Delete Account Start Request Schema
+ * Error messages: DeleteAccountStartRequest.{field}.{rule}
+ */
 exports.DeleteAccountStartRequestSchema = zod_1.z.object({
-    password: zod_1.z.string().min(1),
+    password: zod_1.z
+        .string({ error: 'DeleteAccountStartRequest.password.required' })
+        .min(1, { message: 'DeleteAccountStartRequest.password.min' }),
 });

package/build/v1/users/schemas/email-change-start-request.schema.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+/**
+ * Email Change Start Request Schema
+ * Error messages: EmailChangeStartRequest.{field}.{rule}
+ */
 export declare const EmailChangeStartRequestSchema: z.ZodObject<{
-    newEmail: z.ZodEmail;
+    newEmail: z.ZodString;
 }, z.core.$strip>;

package/build/v1/users/schemas/email-change-start-request.schema.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmailChangeStartRequestSchema = void 0;
 const zod_1 = require("zod");
+/**
+ * Email Change Start Request Schema
+ * Error messages: EmailChangeStartRequest.{field}.{rule}
+ */
 exports.EmailChangeStartRequestSchema = zod_1.z.object({
-    newEmail: zod_1.z.email(),
+    newEmail: zod_1.z
+        .string({ error: 'EmailChangeStartRequest.newEmail.required' })
+        .email({ message: 'EmailChangeStartRequest.newEmail.invalid' }),
 });

package/build/v1/users/schemas/password-change-complete-request.schema.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+/**
+ * Password Change Complete Request Schema
+ * Error messages: PasswordChangeCompleteRequest.{field}.{rule}
+ */
 export declare const PasswordChangeCompleteRequestSchema: z.ZodObject<{
     requestId: z.ZodString;
     newPassword: z.ZodString;

package/build/v1/users/schemas/password-change-complete-request.schema.js

@@ -3,8 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PasswordChangeCompleteRequestSchema = void 0;
 const zod_1 = require("zod");
 const regex_1 = require("../../../shared/regex");
+/**
+ * Password Change Complete Request Schema
+ * Error messages: PasswordChangeCompleteRequest.{field}.{rule}
+ */
 exports.PasswordChangeCompleteRequestSchema = zod_1.z.object({
-    requestId: zod_1.z.string(),
-    newPassword: zod_1.z.string().min(8).max(128).regex(regex_1.PASSWORD_STRENGTH_REGEX),
+    requestId: zod_1.z.string({ error: 'PasswordChangeCompleteRequest.requestId.required' }),
+    newPassword: zod_1.z
+        .string({ error: 'PasswordChangeCompleteRequest.newPassword.required' })
+        .min(8, { message: 'PasswordChangeCompleteRequest.newPassword.min' })
+        .max(128, { message: 'PasswordChangeCompleteRequest.newPassword.max' })
+        .regex(regex_1.PASSWORD_STRENGTH_REGEX, { message: 'PasswordChangeCompleteRequest.newPassword.weak' }),
     logoutOtherSessions: zod_1.z.boolean().default(true),
 });

package/build/v1/users/schemas/password-change-start-request.schema.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+/**
+ * Password Change Start Request Schema
+ * Error messages: PasswordChangeStartRequest.{field}.{rule}
+ */
 export declare const PasswordChangeStartRequestSchema: z.ZodObject<{
     oldPassword: z.ZodString;
 }, z.core.$strip>;

package/build/v1/users/schemas/password-change-start-request.schema.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PasswordChangeStartRequestSchema = void 0;
 const zod_1 = require("zod");
+/**
+ * Password Change Start Request Schema
+ * Error messages: PasswordChangeStartRequest.{field}.{rule}
+ */
 exports.PasswordChangeStartRequestSchema = zod_1.z.object({
-    oldPassword: zod_1.z.string().min(1),
+    oldPassword: zod_1.z
+        .string({ error: 'PasswordChangeStartRequest.oldPassword.required' })
+        .min(1, { message: 'PasswordChangeStartRequest.oldPassword.min' }),
 });