@veruna/api-contracts 1.0.46 → 1.0.47

package/build/shared/pagination.schema.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 /**
  * Pagination query params schema
+ * Error messages: PaginationQuery.{field}.{rule}
  */
 export declare const PaginationQuerySchema: z.ZodObject<{
     page: z.ZodDefault<z.ZodCoercedNumber<unknown>>;

package/build/shared/pagination.schema.js

@@ -4,10 +4,20 @@ exports.createPaginatedResponseSchema = exports.PaginationMetaSchema = exports.P
 const zod_1 = require("zod");
 /**
  * Pagination query params schema
+ * Error messages: PaginationQuery.{field}.{rule}
  */
 exports.PaginationQuerySchema = zod_1.z.object({
-    page: zod_1.z.coerce.number().int().positive().default(1),
-    limit: zod_1.z.coerce.number().int().positive().max(100).default(10),
+    page: zod_1.z.coerce
+        .number()
+        .int({ message: 'PaginationQuery.page.invalid' })
+        .positive({ message: 'PaginationQuery.page.invalid' })
+        .default(1),
+    limit: zod_1.z.coerce
+        .number()
+        .int({ message: 'PaginationQuery.limit.invalid' })
+        .positive({ message: 'PaginationQuery.limit.invalid' })
+        .max(100, { message: 'PaginationQuery.limit.max' })
+        .default(10),
 });
 /**
  * Pagination metadata schema

package/build/v1/ai-model/schemas/create-model-request.schema.d.ts

@@ -4,6 +4,10 @@ import { ModelMark } from './model-mark.enum';
 import { ModelType } from './model-type.enum';
 import { ApiProvider } from './api-provider.enum';
 import { Modality } from './modality.enum';
+/**
+ * Create Model Request Schema
+ * Error messages: CreateModelRequest.{field}.{rule}
+ */
 export declare const CreateModelRequestSchema: z.ZodObject<{
     title: z.ZodString;
     description: z.ZodDefault<z.ZodString>;

package/build/v1/ai-model/schemas/create-model-request.schema.js

@@ -7,25 +7,55 @@ const model_mark_enum_1 = require("./model-mark.enum");
 const model_type_enum_1 = require("./model-type.enum");
 const api_provider_enum_1 = require("./api-provider.enum");
 const modality_enum_1 = require("./modality.enum");
+/**
+ * Create Model Request Schema
+ * Error messages: CreateModelRequest.{field}.{rule}
+ */
 exports.CreateModelRequestSchema = zod_1.z.object({
-    title: zod_1.z.string().min(1).max(255),
+    title: zod_1.z
+        .string({ error: 'CreateModelRequest.title.required' })
+        .min(1, { message: 'CreateModelRequest.title.min' })
+        .max(255, { message: 'CreateModelRequest.title.max' }),
     description: zod_1.z.string().default(''),
-    model: zod_1.z.string().min(1).max(100),
+    model: zod_1.z
+        .string({ error: 'CreateModelRequest.model.required' })
+        .min(1, { message: 'CreateModelRequest.model.min' })
+        .max(100, { message: 'CreateModelRequest.model.max' }),
     icon: zod_1.z
-        .string()
-        .url()
+        .string({ error: 'CreateModelRequest.icon.required' })
+        .url({ message: 'CreateModelRequest.icon.invalid' })
         .refine((url) => url.startsWith('https://'), {
-        message: 'Icon URL must use HTTPS',
+        message: 'CreateModelRequest.icon.https',
     }),
     status: zod_1.z.nativeEnum(ai_model_status_enum_1.AiModelStatus).default(ai_model_status_enum_1.AiModelStatus.ACTIVE),
-    order: zod_1.z.number().int().nonnegative().default(0),
-    providerUuid: zod_1.z.string().uuid().optional(),
+    order: zod_1.z
+        .number()
+        .int({ message: 'CreateModelRequest.order.invalid' })
+        .nonnegative({ message: 'CreateModelRequest.order.invalid' })
+        .default(0),
+    providerUuid: zod_1.z
+        .string()
+        .uuid({ message: 'CreateModelRequest.providerUuid.invalid' })
+        .optional(),
     marks: zod_1.z.array(zod_1.z.nativeEnum(model_mark_enum_1.ModelMark)).default([]),
-    price: zod_1.z.number().int().positive().default(1),
-    speed: zod_1.z.number().int().min(1).max(5).default(3),
+    price: zod_1.z
+        .number()
+        .int({ message: 'CreateModelRequest.price.invalid' })
+        .positive({ message: 'CreateModelRequest.price.invalid' })
+        .default(1),
+    speed: zod_1.z
+        .number()
+        .int()
+        .min(1, { message: 'CreateModelRequest.speed.min' })
+        .max(5, { message: 'CreateModelRequest.speed.max' })
+        .default(3),
     bestFor: zod_1.z.array(zod_1.z.string()).default([]),
     usageExamples: zod_1.z.array(zod_1.z.string()).default([]),
-    contextLength: zod_1.z.number().int().positive().default(128000),
+    contextLength: zod_1.z
+        .number()
+        .int({ message: 'CreateModelRequest.contextLength.invalid' })
+        .positive({ message: 'CreateModelRequest.contextLength.invalid' })
+        .default(128000),
     apiProvider: zod_1.z.nativeEnum(api_provider_enum_1.ApiProvider).default(api_provider_enum_1.ApiProvider.OPENROUTER),
     inputModalities: zod_1.z.array(zod_1.z.nativeEnum(modality_enum_1.Modality)).default([modality_enum_1.Modality.TEXT]),
     outputModalities: zod_1.z.array(zod_1.z.nativeEnum(modality_enum_1.Modality)).default([modality_enum_1.Modality.TEXT]),

package/build/v1/ai-model/schemas/get-models-filters.schema.d.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 import { AiModelStatus } from './ai-model-status.enum';
+/**
+ * Get Models Filters Schema
+ * Error messages: GetModelsFilters.{field}.{rule}
+ */
 export declare const GetModelsFiltersSchema: z.ZodObject<{
     status: z.ZodOptional<z.ZodEnum<typeof AiModelStatus>>;
     providerUuid: z.ZodOptional<z.ZodString>;

package/build/v1/ai-model/schemas/get-models-filters.schema.js

@@ -3,7 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetModelsFiltersSchema = void 0;
 const zod_1 = require("zod");
 const ai_model_status_enum_1 = require("./ai-model-status.enum");
+/**
+ * Get Models Filters Schema
+ * Error messages: GetModelsFilters.{field}.{rule}
+ */
 exports.GetModelsFiltersSchema = zod_1.z.object({
     status: zod_1.z.nativeEnum(ai_model_status_enum_1.AiModelStatus).optional(),
-    providerUuid: zod_1.z.string().uuid().optional(),
+    providerUuid: zod_1.z
+        .string()
+        .uuid({ message: 'GetModelsFilters.providerUuid.invalid' })
+        .optional(),
 });

package/build/v1/ai-model/schemas/route-params.schema.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+/**
+ * Model UUID Params Schema
+ * Error messages: ModelUuidParams.{field}.{rule}
+ */
 export declare const UuidParamsSchema: z.ZodObject<{
     uuid: z.ZodString;
 }, z.core.$strip>;

package/build/v1/ai-model/schemas/route-params.schema.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UuidParamsSchema = void 0;
 const zod_1 = require("zod");
+/**
+ * Model UUID Params Schema
+ * Error messages: ModelUuidParams.{field}.{rule}
+ */
 exports.UuidParamsSchema = zod_1.z.object({
-    uuid: zod_1.z.string().uuid(),
+    uuid: zod_1.z
+        .string({ error: 'ModelUuidParams.uuid.required' })
+        .uuid({ message: 'ModelUuidParams.uuid.invalid' }),
 });

package/build/v1/ai-model/schemas/update-model-request.schema.d.ts

@@ -4,6 +4,10 @@ import { ModelMark } from './model-mark.enum';
 import { ModelType } from './model-type.enum';
 import { ApiProvider } from './api-provider.enum';
 import { Modality } from './modality.enum';
+/**
+ * Update Model Request Schema
+ * Error messages: UpdateModelRequest.{field}.{rule}
+ */
 export declare const UpdateModelRequestSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;

package/build/v1/ai-model/schemas/update-model-request.schema.js

@@ -7,26 +7,59 @@ const model_mark_enum_1 = require("./model-mark.enum");
 const model_type_enum_1 = require("./model-type.enum");
 const api_provider_enum_1 = require("./api-provider.enum");
 const modality_enum_1 = require("./modality.enum");
+/**
+ * Update Model Request Schema
+ * Error messages: UpdateModelRequest.{field}.{rule}
+ */
 exports.UpdateModelRequestSchema = zod_1.z.object({
-    title: zod_1.z.string().min(1).max(255).optional(),
+    title: zod_1.z
+        .string()
+        .min(1, { message: 'UpdateModelRequest.title.min' })
+        .max(255, { message: 'UpdateModelRequest.title.max' })
+        .optional(),
     description: zod_1.z.string().optional(),
-    model: zod_1.z.string().min(1).max(100).optional(),
+    model: zod_1.z
+        .string()
+        .min(1, { message: 'UpdateModelRequest.model.min' })
+        .max(100, { message: 'UpdateModelRequest.model.max' })
+        .optional(),
     icon: zod_1.z
         .string()
-        .url()
+        .url({ message: 'UpdateModelRequest.icon.invalid' })
         .refine((url) => url.startsWith('https://'), {
-        message: 'Icon URL must use HTTPS',
+        message: 'UpdateModelRequest.icon.https',
     })
         .optional(),
     status: zod_1.z.nativeEnum(ai_model_status_enum_1.AiModelStatus).optional(),
-    order: zod_1.z.number().int().nonnegative().optional(),
-    providerUuid: zod_1.z.string().uuid().nullable().optional(),
+    order: zod_1.z
+        .number()
+        .int({ message: 'UpdateModelRequest.order.invalid' })
+        .nonnegative({ message: 'UpdateModelRequest.order.invalid' })
+        .optional(),
+    providerUuid: zod_1.z
+        .string()
+        .uuid({ message: 'UpdateModelRequest.providerUuid.invalid' })
+        .nullable()
+        .optional(),
     marks: zod_1.z.array(zod_1.z.nativeEnum(model_mark_enum_1.ModelMark)).optional(),
-    price: zod_1.z.number().int().positive().optional(),
-    speed: zod_1.z.number().int().min(1).max(5).optional(),
+    price: zod_1.z
+        .number()
+        .int({ message: 'UpdateModelRequest.price.invalid' })
+        .positive({ message: 'UpdateModelRequest.price.invalid' })
+        .optional(),
+    speed: zod_1.z
+        .number()
+        .int()
+        .min(1, { message: 'UpdateModelRequest.speed.min' })
+        .max(5, { message: 'UpdateModelRequest.speed.max' })
+        .optional(),
     bestFor: zod_1.z.array(zod_1.z.string()).optional(),
     usageExamples: zod_1.z.array(zod_1.z.string()).optional(),
-    contextLength: zod_1.z.number().int().positive().optional(),
+    contextLength: zod_1.z
+        .number()
+        .int({ message: 'UpdateModelRequest.contextLength.invalid' })
+        .positive({ message: 'UpdateModelRequest.contextLength.invalid' })
+        .optional(),
     apiProvider: zod_1.z.nativeEnum(api_provider_enum_1.ApiProvider).optional(),
     inputModalities: zod_1.z.array(zod_1.z.nativeEnum(modality_enum_1.Modality)).optional(),
     outputModalities: zod_1.z.array(zod_1.z.nativeEnum(modality_enum_1.Modality)).optional(),

package/build/v1/ai-provider/schemas/create-provider-request.schema.d.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 import { AiProviderStatus } from './ai-provider-status.enum';
+/**
+ * Create Provider Request Schema
+ * Error messages: CreateProviderRequest.{field}.{rule}
+ */
 export declare const CreateProviderRequestSchema: z.ZodObject<{
     title: z.ZodString;
     icon: z.ZodString;

package/build/v1/ai-provider/schemas/create-provider-request.schema.js

@@ -3,14 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateProviderRequestSchema = void 0;
 const zod_1 = require("zod");
 const ai_provider_status_enum_1 = require("./ai-provider-status.enum");
+/**
+ * Create Provider Request Schema
+ * Error messages: CreateProviderRequest.{field}.{rule}
+ */
 exports.CreateProviderRequestSchema = zod_1.z.object({
-    title: zod_1.z.string().min(1).max(100),
+    title: zod_1.z
+        .string({ error: 'CreateProviderRequest.title.required' })
+        .min(1, { message: 'CreateProviderRequest.title.min' })
+        .max(100, { message: 'CreateProviderRequest.title.max' }),
     icon: zod_1.z
-        .string()
-        .url()
+        .string({ error: 'CreateProviderRequest.icon.required' })
+        .url({ message: 'CreateProviderRequest.icon.invalid' })
         .refine((url) => url.startsWith('https://'), {
-        message: 'Icon URL must use HTTPS',
+        message: 'CreateProviderRequest.icon.https',
     }),
     status: zod_1.z.nativeEnum(ai_provider_status_enum_1.AiProviderStatus).default(ai_provider_status_enum_1.AiProviderStatus.ACTIVE),
-    order: zod_1.z.number().int().nonnegative().default(0),
+    order: zod_1.z
+        .number()
+        .int({ message: 'CreateProviderRequest.order.invalid' })
+        .nonnegative({ message: 'CreateProviderRequest.order.invalid' })
+        .default(0),
 });

package/build/v1/ai-provider/schemas/route-params.schema.d.ts

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+/**
+ * Provider UUID Param Schema
+ * Error messages: ProviderUuidParam.{field}.{rule}
+ */
 export declare const ProviderUuidParamSchema: z.ZodObject<{
     uuid: z.ZodString;
 }, z.core.$strip>;

package/build/v1/ai-provider/schemas/route-params.schema.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderUuidParamSchema = void 0;
 const zod_1 = require("zod");
 const shared_1 = require("../../../shared");
+/**
+ * Provider UUID Param Schema
+ * Error messages: ProviderUuidParam.{field}.{rule}
+ */
 exports.ProviderUuidParamSchema = zod_1.z.object({
-    uuid: zod_1.z.string().regex(shared_1.UUID_REGEX),
+    uuid: zod_1.z
+        .string({ error: 'ProviderUuidParam.uuid.required' })
+        .regex(shared_1.UUID_REGEX, { message: 'ProviderUuidParam.uuid.invalid' }),
 });

package/build/v1/ai-provider/schemas/update-provider-request.schema.d.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 import { AiProviderStatus } from './ai-provider-status.enum';
+/**
+ * Update Provider Request Schema
+ * Error messages: UpdateProviderRequest.{field}.{rule}
+ */
 export declare const UpdateProviderRequestSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     icon: z.ZodOptional<z.ZodString>;

package/build/v1/ai-provider/schemas/update-provider-request.schema.js

@@ -3,15 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdateProviderRequestSchema = void 0;
 const zod_1 = require("zod");
 const ai_provider_status_enum_1 = require("./ai-provider-status.enum");
+/**
+ * Update Provider Request Schema
+ * Error messages: UpdateProviderRequest.{field}.{rule}
+ */
 exports.UpdateProviderRequestSchema = zod_1.z.object({
-    title: zod_1.z.string().min(1).max(100).optional(),
+    title: zod_1.z
+        .string()
+        .min(1, { message: 'UpdateProviderRequest.title.min' })
+        .max(100, { message: 'UpdateProviderRequest.title.max' })
+        .optional(),
     icon: zod_1.z
         .string()
-        .url()
+        .url({ message: 'UpdateProviderRequest.icon.invalid' })
         .refine((url) => url.startsWith('https://'), {
-        message: 'Icon URL must use HTTPS',
+        message: 'UpdateProviderRequest.icon.https',
     })
         .optional(),
     status: zod_1.z.nativeEnum(ai_provider_status_enum_1.AiProviderStatus).optional(),
-    order: zod_1.z.number().int().nonnegative().optional(),
+    order: zod_1.z
+        .number()
+        .int({ message: 'UpdateProviderRequest.order.invalid' })
+        .nonnegative({ message: 'UpdateProviderRequest.order.invalid' })
+        .optional(),
 });

package/build/v1/auth/schemas/signin-request.schema.d.ts

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

package/build/v1/auth/schemas/signin-request.schema.js

@@ -5,9 +5,13 @@ const zod_1 = require("zod");
 const regex_1 = require("../../../shared/regex");
 /**
  * SignIn Request Schema
- * Error messages are in locales (en.ts, ru.ts)
+ * Error messages: SignInRequest.{field}.{rule}
  */
 exports.SignInRequestSchema = zod_1.z.object({
-    email: zod_1.z.string().regex(regex_1.EMAIL_REGEX),
-    password: zod_1.z.string().min(1),
+    email: zod_1.z
+        .string({ error: 'SignInRequest.email.required' })
+        .regex(regex_1.EMAIL_REGEX, { message: 'SignInRequest.email.invalid' }),
+    password: zod_1.z
+        .string({ error: 'SignInRequest.password.required' })
+        .min(1, { message: 'SignInRequest.password.min' }),
 });

package/build/v1/auth/schemas/signup-request.schema.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 /**
  * Sign Up Request Schema
- * Error messages are in locales (en.ts, ru.ts)
+ * Error messages: SignUpRequest.{field}.{rule}
  */
 export declare const SignUpRequestSchema: z.ZodObject<{
     email: z.ZodString;

package/build/v1/auth/schemas/signup-request.schema.js

@@ -5,11 +5,19 @@ const zod_1 = require("zod");
 const regex_1 = require("../../../shared/regex");
 /**
  * Sign Up Request Schema
- * Error messages are in locales (en.ts, ru.ts)
+ * Error messages: SignUpRequest.{field}.{rule}
  */
 exports.SignUpRequestSchema = zod_1.z.object({
-    email: zod_1.z.string().regex(regex_1.EMAIL_REGEX),
-    password: zod_1.z.string().min(8).max(128).regex(regex_1.PASSWORD_STRENGTH_REGEX),
-    name: zod_1.z.string().min(2),
+    email: zod_1.z
+        .string({ error: 'SignUpRequest.email.required' })
+        .regex(regex_1.EMAIL_REGEX, { message: 'SignUpRequest.email.invalid' }),
+    password: zod_1.z
+        .string({ error: 'SignUpRequest.password.required' })
+        .min(8, { message: 'SignUpRequest.password.min' })
+        .max(128, { message: 'SignUpRequest.password.max' })
+        .regex(regex_1.PASSWORD_STRENGTH_REGEX, { message: 'SignUpRequest.password.weak' }),
+    name: zod_1.z
+        .string({ error: 'SignUpRequest.name.required' })
+        .min(2, { message: 'SignUpRequest.name.min' }),
     marketingConsent: zod_1.z.boolean().default(false),
 });

package/build/v1/blog/schemas/create-category-request.schema.d.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 import { BlogCategoryStatus } from './blog-category-status.enum';
+/**
+ * Create Category Request Schema
+ * Error messages: CreateCategoryRequest.{field}.{rule}
+ */
 export declare const CreateCategoryRequestSchema: z.ZodObject<{
     alias: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     title: z.ZodString;

package/build/v1/blog/schemas/create-category-request.schema.js

@@ -4,9 +4,21 @@ exports.CreateCategoryRequestSchema = void 0;
 const zod_1 = require("zod");
 const shared_1 = require("../../../shared");
 const blog_category_status_enum_1 = require("./blog-category-status.enum");
+/**
+ * Create Category Request Schema
+ * Error messages: CreateCategoryRequest.{field}.{rule}
+ */
 exports.CreateCategoryRequestSchema = zod_1.z.object({
-    alias: zod_1.z.string().min(1).max(100).regex(shared_1.SLUG_REGEX).transform(val => val.toLowerCase().trim()),
-    title: zod_1.z.string().min(1).max(200),
-    order: zod_1.z.number().int().nonnegative().default(0),
-    status: zod_1.z.enum(blog_category_status_enum_1.BlogCategoryStatus).default(blog_category_status_enum_1.BlogCategoryStatus.DRAFT),
+    alias: zod_1.z
+        .string({ error: 'CreateCategoryRequest.alias.required' })
+        .min(1, { message: 'CreateCategoryRequest.alias.min' })
+        .max(100, { message: 'CreateCategoryRequest.alias.max' })
+        .regex(shared_1.SLUG_REGEX, { message: 'CreateCategoryRequest.alias.invalid' })
+        .transform((val) => val.toLowerCase().trim()),
+    title: zod_1.z
+        .string({ error: 'CreateCategoryRequest.title.required' })
+        .min(1, { message: 'CreateCategoryRequest.title.min' })
+        .max(200, { message: 'CreateCategoryRequest.title.max' }),
+    order: zod_1.z.number().int().nonnegative({ message: 'CreateCategoryRequest.order.invalid' }).default(0),
+    status: zod_1.z.nativeEnum(blog_category_status_enum_1.BlogCategoryStatus).default(blog_category_status_enum_1.BlogCategoryStatus.DRAFT),
 });

package/build/v1/blog/schemas/create-post-request.schema.d.ts

@@ -1,6 +1,10 @@
 import { z } from 'zod';
 import { BlogPostStatus } from './blog-post-status.enum';
 import { BlogPostMark } from './blog-post-mark.enum';
+/**
+ * Create Post Request Schema
+ * Error messages: CreatePostRequest.{field}.{rule}
+ */
 export declare const CreatePostRequestSchema: z.ZodObject<{
     alias: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     title: z.ZodString;

package/build/v1/blog/schemas/create-post-request.schema.js

@@ -5,27 +5,62 @@ const zod_1 = require("zod");
 const shared_1 = require("../../../shared");
 const blog_post_status_enum_1 = require("./blog-post-status.enum");
 const blog_post_mark_enum_1 = require("./blog-post-mark.enum");
+/**
+ * Create Post Request Schema
+ * Error messages: CreatePostRequest.{field}.{rule}
+ */
 exports.CreatePostRequestSchema = zod_1.z
     .object({
     alias: zod_1.z
-        .string()
-        .min(1)
-        .max(200)
-        .regex(shared_1.SLUG_REGEX)
+        .string({ error: 'CreatePostRequest.alias.required' })
+        .min(1, { message: 'CreatePostRequest.alias.min' })
+        .max(200, { message: 'CreatePostRequest.alias.max' })
+        .regex(shared_1.SLUG_REGEX, { message: 'CreatePostRequest.alias.invalid' })
         .transform((val) => val.toLowerCase().trim()),
-    title: zod_1.z.string().min(1).max(300),
-    description: zod_1.z.string().max(1000),
-    metaTitle: zod_1.z.string().min(1).max(100),
-    metaDescription: zod_1.z.string().min(1).max(200),
-    content: zod_1.z.string().min(1).max(1000000),
-    image: zod_1.z.string().url(),
-    author: zod_1.z.string().min(1).max(100),
-    categoryIds: zod_1.z.array(zod_1.z.string().regex(shared_1.UUID_REGEX)).min(1),
+    title: zod_1.z
+        .string({ error: 'CreatePostRequest.title.required' })
+        .min(1, { message: 'CreatePostRequest.title.min' })
+        .max(300, { message: 'CreatePostRequest.title.max' }),
+    description: zod_1.z.string().max(1000, { message: 'CreatePostRequest.description.max' }),
+    metaTitle: zod_1.z
+        .string({ error: 'CreatePostRequest.metaTitle.required' })
+        .min(1, { message: 'CreatePostRequest.metaTitle.min' })
+        .max(100, { message: 'CreatePostRequest.metaTitle.max' }),
+    metaDescription: zod_1.z
+        .string({ error: 'CreatePostRequest.metaDescription.required' })
+        .min(1, { message: 'CreatePostRequest.metaDescription.min' })
+        .max(200, { message: 'CreatePostRequest.metaDescription.max' }),
+    content: zod_1.z
+        .string({ error: 'CreatePostRequest.content.required' })
+        .min(1, { message: 'CreatePostRequest.content.min' })
+        .max(1000000, { message: 'CreatePostRequest.content.max' }),
+    image: zod_1.z
+        .string({ error: 'CreatePostRequest.image.required' })
+        .url({ message: 'CreatePostRequest.image.invalid' }),
+    author: zod_1.z
+        .string({ error: 'CreatePostRequest.author.required' })
+        .min(1, { message: 'CreatePostRequest.author.min' })
+        .max(100, { message: 'CreatePostRequest.author.max' }),
+    categoryIds: zod_1.z
+        .array(zod_1.z.string().regex(shared_1.UUID_REGEX, { message: 'CreatePostRequest.categoryIds.invalidUuid' }))
+        .min(1, { message: 'CreatePostRequest.categoryIds.min' }),
     status: zod_1.z.nativeEnum(blog_post_status_enum_1.BlogPostStatus).default(blog_post_status_enum_1.BlogPostStatus.DRAFT),
-    pageId: zod_1.z.string().regex(shared_1.UUID_REGEX).nullable().optional(),
+    pageId: zod_1.z
+        .string()
+        .regex(shared_1.UUID_REGEX, { message: 'CreatePostRequest.pageId.invalidUuid' })
+        .nullable()
+        .optional(),
     marks: zod_1.z.array(zod_1.z.nativeEnum(blog_post_mark_enum_1.BlogPostMark)).default([]),
-    aiWidgetPlaceholder: zod_1.z.string().max(500).nullable().optional(),
-    aiWidgetPrompt: zod_1.z.string().max(2000).nullable().optional(),
+    aiWidgetPlaceholder: zod_1.z
+        .string()
+        .max(500, { message: 'CreatePostRequest.aiWidgetPlaceholder.max' })
+        .nullable()
+        .optional(),
+    aiWidgetPrompt: zod_1.z
+        .string()
+        .max(2000, { message: 'CreatePostRequest.aiWidgetPrompt.max' })
+        .nullable()
+        .optional(),
 })
     .refine((data) => {
     if (data.marks.includes(blog_post_mark_enum_1.BlogPostMark.AI_WIDGET)) {
@@ -33,5 +68,5 @@ exports.CreatePostRequestSchema = zod_1.z
     }
     return true;
 }, {
-    message: 'pageId, aiWidgetPlaceholder and aiWidgetPrompt are required when AI_WIDGET mark is present',
+    message: 'CreatePostRequest.aiWidgetRequired',
 });

package/build/v1/blog/schemas/route-params.schema.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 /**
  * Schema for UUID route parameter validation
  * Used in admin endpoints: GET /posts/:uuid, DELETE /posts/:uuid, etc.
+ * Error messages: UuidParam.{field}.{rule}
  */
 export declare const UuidParamSchema: z.ZodObject<{
     uuid: z.ZodString;
@@ -9,6 +10,7 @@ export declare const UuidParamSchema: z.ZodObject<{
 /**
  * Schema for alias route parameter validation
  * Used in public endpoints: GET /posts/:alias
+ * Error messages: AliasParam.{field}.{rule}
  */
 export declare const AliasParamSchema: z.ZodObject<{
     alias: z.ZodString;

package/build/v1/blog/schemas/route-params.schema.js

@@ -6,18 +6,22 @@ const regex_1 = require("../../../shared/regex");
 /**
  * Schema for UUID route parameter validation
  * Used in admin endpoints: GET /posts/:uuid, DELETE /posts/:uuid, etc.
+ * Error messages: UuidParam.{field}.{rule}
  */
 exports.UuidParamSchema = zod_1.z.object({
-    uuid: zod_1.z.string().uuid({ message: 'Invalid UUID format' }),
+    uuid: zod_1.z
+        .string({ error: 'UuidParam.uuid.required' })
+        .uuid({ message: 'UuidParam.uuid.invalid' }),
 });
 /**
  * Schema for alias route parameter validation
  * Used in public endpoints: GET /posts/:alias
+ * Error messages: AliasParam.{field}.{rule}
  */
 exports.AliasParamSchema = zod_1.z.object({
     alias: zod_1.z
-        .string()
-        .min(1, { message: 'Alias cannot be empty' })
-        .max(200, { message: 'Alias too long (max 200 characters)' })
-        .regex(regex_1.SLUG_REGEX, { message: 'Alias must contain only lowercase letters, numbers, and hyphens' }),
+        .string({ error: 'AliasParam.alias.required' })
+        .min(1, { message: 'AliasParam.alias.min' })
+        .max(200, { message: 'AliasParam.alias.max' })
+        .regex(regex_1.SLUG_REGEX, { message: 'AliasParam.alias.invalid' }),
 });

package/build/v1/blog/schemas/update-category-request.schema.d.ts

@@ -1,5 +1,9 @@
 import { z } from 'zod';
 import { BlogCategoryStatus } from './blog-category-status.enum';
+/**
+ * Update Category Request Schema
+ * Error messages: UpdateCategoryRequest.{field}.{rule}
+ */
 export declare const UpdateCategoryRequestSchema: z.ZodObject<{
     alias: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
     title: z.ZodOptional<z.ZodString>;

package/build/v1/blog/schemas/update-category-request.schema.js

@@ -4,9 +4,23 @@ exports.UpdateCategoryRequestSchema = void 0;
 const zod_1 = require("zod");
 const regex_1 = require("../../../shared/regex");
 const blog_category_status_enum_1 = require("./blog-category-status.enum");
+/**
+ * Update Category Request Schema
+ * Error messages: UpdateCategoryRequest.{field}.{rule}
+ */
 exports.UpdateCategoryRequestSchema = zod_1.z.object({
-    alias: zod_1.z.string().min(1).max(100).regex(regex_1.SLUG_REGEX).transform(val => val.toLowerCase().trim()).optional(),
-    title: zod_1.z.string().min(1).max(200).optional(),
-    order: zod_1.z.number().int().nonnegative().optional(),
+    alias: zod_1.z
+        .string()
+        .min(1, { message: 'UpdateCategoryRequest.alias.min' })
+        .max(100, { message: 'UpdateCategoryRequest.alias.max' })
+        .regex(regex_1.SLUG_REGEX, { message: 'UpdateCategoryRequest.alias.invalid' })
+        .transform((val) => val.toLowerCase().trim())
+        .optional(),
+    title: zod_1.z
+        .string()
+        .min(1, { message: 'UpdateCategoryRequest.title.min' })
+        .max(200, { message: 'UpdateCategoryRequest.title.max' })
+        .optional(),
+    order: zod_1.z.number().int().nonnegative({ message: 'UpdateCategoryRequest.order.invalid' }).optional(),
     status: zod_1.z.nativeEnum(blog_category_status_enum_1.BlogCategoryStatus).optional(),
 });