@floristcloud/api-lib 1.0.19 → 1.0.21

package/commands/message/get-contexts-with-unread.query.ts

@@ -3,8 +3,8 @@ import { ContextMessageContextTypeEnum } from '../../enum/context-message-contex
 import { ContextInboxListSchema } from '../../schemas/message/context-inbox.schema';
 
 const GetContextsWithUnreadRequestSchema = z.object({
-    contextType: z.nativeEnum(ContextMessageContextTypeEnum).optional(),
-    clientUUID: z.string().uuid().optional(),
+    contextType: z.enum(ContextMessageContextTypeEnum).optional(),
+    clientUUID: z.uuid().optional(),
     onlyMy: z.coerce.boolean().optional().default(false),
     page: z.coerce.number().optional().default(1),
     count: z.coerce.number().optional().default(20),

package/commands/message/list-context-messages.query.ts

@@ -3,12 +3,12 @@ import { ContextMessageListSchema } from '../../schemas/message/context-message-
 import { ContextMessageContextTypeEnum } from '../../enum/context-message-context-type.enum';
 
 const ListContextMessagesRequestSchema = z.object({
-    contextType: z.nativeEnum(ContextMessageContextTypeEnum),
-    contextUUID: z.string().uuid(),
-    subjectUUID: z.string().uuid().optional(),
+    contextType: z.enum(ContextMessageContextTypeEnum),
+    contextUUID: z.uuid(),
+    subjectUUID: z.uuid().optional(),
     limit: z.coerce.number().optional().default(50),
-    before: z.string().datetime().optional(),
-    after: z.string().datetime().optional(),
+    before: z.string().optional(),
+    after: z.string().optional(),
 });
 
 const ListContextMessagesResponseSchema = z.object({

package/commands/message/mark-context-read.command.ts

@@ -2,9 +2,9 @@ import { z } from 'zod';
 import { ContextMessageContextTypeEnum } from '../../enum/context-message-context-type.enum';
 
 const MarkContextReadRequestSchema = z.object({
-    contextType: z.nativeEnum(ContextMessageContextTypeEnum),
-    contextUUID: z.string().uuid(),
-    subjectUUID: z.string().uuid().optional(),
+    contextType: z.enum(ContextMessageContextTypeEnum),
+    contextUUID: z.uuid(),
+    subjectUUID: z.uuid().optional(),
 });
 
 const MarkContextReadResponseSchema = z.object({

package/commands/message/send-context-message.command.ts

@@ -3,9 +3,9 @@ import { ContextMessageSchema } from '../../schemas/message/context-message.sche
 import { ContextMessageContextTypeEnum } from '../../enum/context-message-context-type.enum';
 
 const SendContextMessageRequestSchema = z.object({
-    contextType: z.nativeEnum(ContextMessageContextTypeEnum),
-    contextUUID: z.string().uuid(),
-    subjectUUID: z.string().uuid().optional(),
+    contextType: z.enum(ContextMessageContextTypeEnum),
+    contextUUID: z.uuid(),
+    subjectUUID: z.uuid().optional(),
     text: z.string().min(1).max(2000),
     payload: z.any().optional(),
 });

package/commands/order/create-order.command.ts

@@ -3,11 +3,11 @@ import { OrderTypeEnum } from '../../enum';
 import { OrderDeliverySchema, OrderSchema } from '../../schemas';
 
 const CreateOrderRequestSchema = z.object({
-    clientUUID: z.string().uuid(),
-    branchUUID: z.string().uuid().nullable(),
+    clientUUID: z.uuid(),
+    branchUUID: z.uuid().nullable(),
     deliveryCost: z.number(),
     deliveryVat: z.number().nullable(),
-    type: z.nativeEnum(OrderTypeEnum),
+    type: z.enum(OrderTypeEnum),
     comment: z.string().nullable(),
     clientComment: z.string().nullable(),
     tag: z.string().nullable(),

package/commands/order/get-order-list.query.ts

@@ -17,8 +17,8 @@ const GetOrderListRequestSchema = z
         searchQuery: z.string().optional(),
         consignmentDeliveryDate: z.coerce.date().optional(),
         byProductSearchQuery: z.string().optional(),
-        statuses: z.nativeEnum(OrderStatusEnum).array().optional(),
-        type: z.nativeEnum(OrderTypeEnum).optional(),
+        statuses: z.enum(OrderStatusEnum).array().optional(),
+        type: z.enum(OrderTypeEnum).optional(),
         city: z.string().optional(),
         responsibleUserUUID: z.string().optional(),
         group: z.string().optional(),

package/commands/order/group/update-group-order-status.command.ts

@@ -3,7 +3,7 @@ import { OrderStatusEnum } from '../../../enum';
 
 const UpdateGroupOrderStatusRequestSchema = z.object({
     orderUUIDList: z.array(z.string()),
-    status: z.nativeEnum(OrderStatusEnum),
+    status: z.enum(OrderStatusEnum),
 });
 
 const UpdateGroupOrderStatusResponseSchema = z.object({

package/commands/order/group/update-group-order-type.command.ts

@@ -3,7 +3,7 @@ import { OrderTypeEnum } from '../../../enum';
 
 const UpdateGroupOrderTypeRequestSchema = z.object({
     orderUUIDList: z.array(z.string()),
-    type: z.nativeEnum(OrderTypeEnum),
+    type: z.enum(OrderTypeEnum),
 });
 
 const UpdateGroupOrderTypeResponseSchema = z.object({

package/commands/order/update-order.command.ts

@@ -3,14 +3,14 @@ import { OrderStatusEnum, OrderTypeEnum } from '../../enum';
 import { OrderSchema } from '../../schemas';
 
 const UpdateOrderRequestSchema = z.object({
-    clientUUID: z.string().uuid(),
-    branchUUID: z.string().uuid().nullable(),
+    clientUUID: z.uuid(),
+    branchUUID: z.uuid().nullable(),
     deliveryCost: z.coerce.number(),
-    type: z.nativeEnum(OrderTypeEnum),
+    type: z.enum(OrderTypeEnum),
     comment: z.string().nullable(),
     clientComment: z.string().nullable(),
     tag: z.string().nullable(),
-    status: z.nativeEnum(OrderStatusEnum),
+    status: z.enum(OrderStatusEnum),
     isPaid: z.coerce.boolean(),
     deliveryVat: z.coerce.number().nullable(),
     deliveryVatAmount: z.coerce.number(),

package/commands/order/webshop/update-cart.command.ts

@@ -3,7 +3,7 @@ import { OrderForClientSchema } from '../../../schemas';
 
 const UpdateCartRequestSchema = z.object({
     clientComment: z.string().nullable().optional().default(null),
-    branchUUID: z.string().uuid().optional().nullable().default(null),
+    branchUUID: z.uuid().optional().nullable().default(null),
     delivery: z
         .object({
             deliveryDate: z.coerce.date().optional().nullable().default(null),

package/commands/order-delivery/update-order-delivery.command.ts

@@ -9,7 +9,7 @@ const UpdateOrderDeliveryRequestSchema = z
         address: z.string().nullable(),
         time: z.string().nullable(),
         comment: z.string().nullable(),
-        orderDeliveryStatus: z.nativeEnum(OrderDeliveryStatusEnum),
+        orderDeliveryStatus: z.enum(OrderDeliveryStatusEnum),
     })
     .partial();
 

package/commands/order-product/create-order-product.command.ts

@@ -7,7 +7,7 @@ const CreateOrderProductRequestSchema = z.object({
     comment: z.string().nullable(),
     tag: z.string().nullable(),
     isEditable: z.coerce.boolean(),
-    multiplicityOptionUUID: z.string().uuid().nullable().optional(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
 });
 
 const CreateOrderProductResponseSchema = z.object({

package/commands/order-product/group/update-group-order-product-order.command.ts

@@ -7,7 +7,7 @@ const UpdateGroupOrderProductOrderRequestSchema = z.object({
             quantity: z.coerce.number(),
         }),
     ),
-    newOrderUUID: z.string().uuid(),
+    newOrderUUID: z.uuid(),
     isDelete: z.coerce.boolean().optional().default(true),
     isComment: z.coerce.boolean().optional().default(true),
 });

package/commands/order-product/update-order-product.command.ts

@@ -2,13 +2,13 @@ import { z } from 'zod';
 import { OrderProductSchema } from '../../schemas';
 
 const UpdateOrderProductRequestSchema = z.object({
-    productUUID: z.string().uuid(),
+    productUUID: z.uuid(),
     quantity: z.number(),
     price: z.number(),
     comment: z.string().nullable(),
     tag: z.string().nullable(),
     isEditable: z.coerce.boolean(),
-    multiplicityOptionUUID: z.string().uuid().nullable().optional(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
 });
 
 const UpdateOrderProductResponseSchema = z.object({

package/commands/order-product/webshop/create-order-product-for-client.command.ts

@@ -3,7 +3,7 @@ import { OrderProductForClientSchema } from '../../../schemas';
 
 const CreateOrderProductClientRequestSchema = z.object({
     quantity: z.number().positive({ message: 'Количество должно быть больше нуля' }),
-    optionUUID: z.string().uuid().optional().nullable(),
+    optionUUID: z.uuid().optional().nullable(),
 });
 
 const CreateOrderProductClientResponseSchema = z.object({

package/commands/order-product/webshop/update-order-product-for-client.command.ts

@@ -4,7 +4,7 @@ import { OrderProductForClientSchema } from '../../../schemas';
 const UpdateOrderProductForClientRequestSchema = z.object({
     quantity: z.coerce.number().optional(),
     comment: z.string().optional(),
-    optionUUID: z.string().uuid().nullable().optional(),
+    optionUUID: z.uuid().nullable().optional(),
 });
 
 const UpdateOrderProductForClientResponseSchema = z.object({

package/commands/package/get-package-filters-values.query.ts

@@ -10,8 +10,8 @@ const GetPackageFiltersValuesResponseSchema = z.object({
                 uuid: z.string(),
                 displayId: z.string(),
                 marking: z.string().nullable(),
-                type: z.nativeEnum(PackageTypeEnum),
-                status: z.nativeEnum(PackageStatusEnum),
+                type: z.enum(PackageTypeEnum),
+                status: z.enum(PackageStatusEnum),
             }),
         ),
         clientList: z.array(

package/commands/package/reorder-packages.command.ts

@@ -4,7 +4,7 @@ const ReorderPackagesRequestSchema = z.object({
     items: z
         .array(
             z.object({
-                uuid: z.string().uuid(),
+                uuid: z.uuid(),
                 rank: z.coerce.number().int().min(0),
             }),
         )

package/commands/pre-order/create-order-from-pre-order.command.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { OrderSchema } from '../../schemas';
 
 const CreateOrderFromPreOrderRequestSchema = z.object({
-    consignmentUUIDList: z.string().uuid().array(),
+    consignmentUUIDList: z.uuid().array(),
 });
 
 const CreateOrderFromPreOrderResponseSchema = z.object({

package/commands/pre-order/get-pre-order-list.query.ts

@@ -7,7 +7,7 @@ const GetPreOrderListRequestSchema = z.object({
     count: z.coerce.number().optional().default(10),
     searchQuery: z.string().optional(),
     preOrderCollectionUUID: z.string().optional(),
-    status: z.nativeEnum(PreOrderStatusEnum).array().optional(),
+    status: z.enum(PreOrderStatusEnum).array().optional(),
     createdAtFrom: z.coerce.date().optional(),
     createdAtTo: z.coerce.date().optional(),
     responsibleUserUUID: z.string().optional(),

package/commands/pre-order/group/analyze-copy-pre-orders.command.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { MatchingConfigSchema, CopyAnalysisSchema } from '../../../schemas';
 
 const AnalyzeCopyPreOrdersRequestSchema = z.object({
-    preOrderUUIDList: z.array(z.string().uuid()),
-    targetPreOrderCollectionUUID: z.string().uuid(),
+    preOrderUUIDList: z.array(z.uuid()),
+    targetPreOrderCollectionUUID: z.uuid(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
 });
 

package/commands/pre-order/group/analyze-create-orders-from-pre-orders.command.ts

@@ -7,8 +7,8 @@ import {
 } from '../../../schemas';
 
 const AnalyzeCreateOrdersFromPreOrdersRequestSchema = z.object({
-    preOrderUUIDs: z.string().uuid().array(),
-    consignmentUUIDs: z.string().uuid().array(),
+    preOrderUUIDs: z.uuid().array(),
+    consignmentUUIDs: z.uuid().array(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
     isProportionalAllocation: z.coerce.boolean().optional(),
 });

package/commands/pre-order/group/analyze-create-pre-orders-from-standing-orders.command.ts

@@ -7,8 +7,8 @@ import {
 } from '../../../schemas';
 
 const AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema = z.object({
-    standingOrderUUIDs: z.string().uuid().array(),
-    preOrderCollectionUUIDs: z.string().uuid().array(),
+    standingOrderUUIDs: z.uuid().array(),
+    preOrderCollectionUUIDs: z.uuid().array(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
 });
 

package/commands/pre-order/group/group-copy-pre-orders-to-collection.command.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { MatchingConfigSchema } from '../../../schemas/pre-order-product/pre-order-product.schema';
 
 const GroupCopyPreOrdersToCollectionRequestSchema = z.object({
-    preOrderUUIDList: z.array(z.string().uuid()),
-    targetPreOrderCollectionUUID: z.string().uuid(),
+    preOrderUUIDList: z.array(z.uuid()),
+    targetPreOrderCollectionUUID: z.uuid(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
 });
 

package/commands/pre-order/group/group-create-orders-from-pre-orders.command.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { MatchingConfigSchema, OrderSchema } from '../../../schemas';
 
 const GroupCreateOrdersFromPreOrdersRequestSchema = z.object({
-    preOrderUUIDs: z.string().uuid().array(),
-    consignmentUUIDs: z.string().uuid().array(),
+    preOrderUUIDs: z.uuid().array(),
+    consignmentUUIDs: z.uuid().array(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
     isProportionalAllocation: z.coerce.boolean().optional(),
 });
@@ -13,7 +13,7 @@ const GroupCreateOrdersFromPreOrdersResponseSchema = z.object({
     data: z.object({
         created: z
             .object({
-                preOrderUUID: z.string().uuid(),
+                preOrderUUID: z.uuid(),
                 orders: OrderSchema.extend({
                     warnings: z.string().array(),
                 }).array(),
@@ -21,7 +21,7 @@ const GroupCreateOrdersFromPreOrdersResponseSchema = z.object({
             .array(),
         failed: z
             .object({
-                preOrderUUID: z.string().uuid(),
+                preOrderUUID: z.uuid(),
                 error: z.object({
                     code: z.string(),
                     message: z.string(),

package/commands/pre-order/group/group-create-pre-orders-from-standing-orders.command.ts

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { MatchingConfigSchema, PreOrderSchema } from '../../../schemas';
 
 const GroupCreatePreOrdersFromStandingOrdersRequestSchema = z.object({
-    standingOrderUUIDs: z.string().uuid().array(),
-    preOrderCollectionUUIDs: z.string().uuid().array(),
+    standingOrderUUIDs: z.uuid().array(),
+    preOrderCollectionUUIDs: z.uuid().array(),
     matchingConfig: MatchingConfigSchema.optional().nullable(),
 });
 
@@ -12,14 +12,14 @@ const GroupCreatePreOrdersFromStandingOrdersResponseSchema = z.object({
     data: z.object({
         created: z
             .object({
-                standingOrderUUID: z.string().uuid(),
+                standingOrderUUID: z.uuid(),
                 preOrders: PreOrderSchema.array(),
                 warnings: z.string().array(),
             })
             .array(),
         failed: z
             .object({
-                standingOrderUUID: z.string().uuid(),
+                standingOrderUUID: z.uuid(),
                 error: z.object({
                     code: z.string(),
                     message: z.string(),

package/commands/pre-order/webshop/get-pre-order-list-webshop.command.ts

@@ -5,7 +5,7 @@ import { PreOrderListSchema } from '../../../schemas';
 const GetPreOrderListWebshopRequestSchema = z.object({
     page: z.coerce.number().optional().default(1),
     count: z.coerce.number().optional().default(10),
-    statuses: z.array(z.nativeEnum(PreOrderStatusEnum)).optional(),
+    statuses: z.array(z.enum(PreOrderStatusEnum)).optional(),
 });
 
 const GetPreOrderListResponseSchema = z.object({

package/commands/pre-order-collection/get-pre-order-collection-list.query.ts

@@ -6,7 +6,7 @@ const GetPreOrderCollectionListRequestSchema = z.object({
     page: z.coerce.number().optional().default(1),
     count: z.coerce.number().optional().default(10),
     searchQuery: z.string().optional(),
-    status: z.nativeEnum(PreOrderCollectionStatusEnum).optional(),
+    status: z.enum(PreOrderCollectionStatusEnum).optional(),
     startDate: z.coerce.date().optional(),
     endDate: z.coerce.date().optional(),
 });

package/commands/pre-order-collection/match-images-for-collection.command.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 
 const MatchImagesRequestSchema = z.object({
     onlyWithoutImages: z.coerce.boolean().default(true),
-    uuidList: z.array(z.string().uuid()).optional(),
+    uuidList: z.array(z.uuid()).optional(),
 });
 
 const MatchImagesResponseSchema = z.object({

package/commands/pre-order-collection-item/export-pre-order-collection-item-with-clients-vertical.query.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { PreOrderAggregationModeEnum } from '../../enum';
 
 const ExportPreOrderCollectionItemWithClientsVerticalRequestSchema = z.object({
-    aggregationMode: z.nativeEnum(PreOrderAggregationModeEnum).optional().default(PreOrderAggregationModeEnum.ITEM),
+    aggregationMode: z.enum(PreOrderAggregationModeEnum).optional().default(PreOrderAggregationModeEnum.ITEM),
 });
 
 const ExportPreOrderCollectionItemWithClientsVerticalResponseSchema = z.object({

package/commands/pre-order-collection-item/get-pre-order-collection-item-extended-with-clients-pre-order-product-list.query.ts

@@ -5,7 +5,7 @@ import { PreOrderStatusEnum } from '../../enum';
 const GetPreOrderCollectionItemExtendedWithClientsPreOrderProductListRequestSchema = z.object({
     preOrderCollectionUUID: z.string().optional(),
     searchQuery: z.string().optional(),
-    statuses: z.nativeEnum(PreOrderStatusEnum).array().optional(),
+    statuses: z.enum(PreOrderStatusEnum).array().optional(),
     preOrderCreatedAtFrom: z.coerce.date().optional(),
     preOrderCreatedAtTo: z.coerce.date().optional(),
 });

package/commands/pre-order-collection-item/multiplicity-option/reorder-pre-order-collection-item-multiplicity-options.command.ts

@@ -4,7 +4,7 @@ const ReorderPreOrderCollectionItemMultiplicityOptionsRequestSchema = z.object({
     items: z
         .array(
             z.object({
-                optionUUID: z.string().uuid(),
+                optionUUID: z.uuid(),
                 rank: z.coerce.number().int().min(0),
             }),
         )

package/commands/product/get-product-quantity-calculate.query.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 const GetProductQuantityCalculateRequestSchema = z.object({
-    productUUIDList: z.string().uuid().array(),
+    productUUIDList: z.uuid().array(),
 });
 
 const GetProductQuantityCalculateResponseSchema = z.object({

package/commands/product/group/update-group-product-update-batch.command.ts

@@ -31,7 +31,7 @@ const UpdateGroupProductUpdateBatchResponseSchema = z.object({
         errors: z
             .array(
                 z.object({
-                    productUUID: z.string().uuid(),
+                    productUUID: z.uuid(),
                     message: z.string(),
                 }),
             )

package/commands/product/multiplicity-option/reorder-product-multiplicity-options.command.ts

@@ -4,7 +4,7 @@ const ReorderProductMultiplicityOptionsRequestSchema = z.object({
     items: z
         .array(
             z.object({
-                optionUUID: z.string().uuid(),
+                optionUUID: z.uuid(),
                 rank: z.coerce.number().int().min(0),
             }),
         )

package/commands/product-configuration/get-product-configuration-list.query.ts

@@ -6,7 +6,7 @@ const GetProductConfigurationListRequestSchema = z.object({
     page: z.coerce.number().optional().default(1),
     count: z.coerce.number().optional().default(10),
     categoryUUID: z.string().optional(),
-    country: z.nativeEnum(CountryCodeEnum).optional(),
+    country: z.enum(CountryCodeEnum).optional(),
     grower: z.string().optional(),
     size: z.coerce.number().optional(),
     isOptional: z.coerce.boolean().optional(),

package/commands/product-image/get-product-image-list.query.ts

@@ -5,7 +5,7 @@ import { ProductImageOrderByEnum } from '../../enum';
 const GetProductImageListRequestSchema = z.object({
     page: z.string().transform(val => Number(val) || 1),
     count: z.string().transform(val => Number(val) || 10),
-    orderBy: z.nativeEnum(ProductImageOrderByEnum).optional(),
+    orderBy: z.enum(ProductImageOrderByEnum).optional(),
     searchQuery: z.string().optional(),
     productUUID: z.string().optional(),
     categoryUUID: z.string().optional(),

package/commands/report/export-client-statement.query.ts

@@ -6,7 +6,7 @@ const ExportClientStatementRequestSchema = z
     .object({
         startDate: z.coerce.date().optional(),
         endDate: z.coerce.date().optional(),
-        clientUUID: z.string().uuid(),
+        clientUUID: z.uuid(),
     })
     .refine(
         value => {

package/commands/report/export-inventory-movement.query.ts

@@ -6,7 +6,7 @@ const ExportInventoryMovementRequestSchema = z
     .object({
         startDate: z.coerce.date().optional(),
         endDate: z.coerce.date().optional(),
-        categoryUUID: z.string().uuid().optional(), // Фильтр по категории
+        categoryUUID: z.uuid().optional(), // Фильтр по категории
         detailed: z.coerce.boolean().optional().default(false), // Флаг для детализации
     })
     .refine(
@@ -28,7 +28,7 @@ const CategoryMovementItemSchema = z.object({
     date: z.string(),
     categoryUUID: z.string(),
     categoryName: z.string(),
-    movementType: z.nativeEnum(InventoryMovementTypeEnum), // тип движения как enum
+    movementType: z.enum(InventoryMovementTypeEnum), // тип движения как enum
     quantity: z.number(),
 });
 
@@ -41,7 +41,7 @@ const DetailedMovementItemSchema = z.object({
     color: z.string().nullable(),
     size: z.string().nullable(),
     grower: z.string().nullable(),
-    movementType: z.nativeEnum(InventoryMovementTypeEnum), // тип движения как enum
+    movementType: z.enum(InventoryMovementTypeEnum), // тип движения как enum
     quantity: z.number(),
     documentNumber: z.string().nullable(), // номер документа
 });

package/commands/report/export-inventory-stock.query.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 const ExportInventoryStockRequestSchema = z.object({
-    categoryUUID: z.string().uuid().optional(), // Фильтр по категории
+    categoryUUID: z.uuid().optional(), // Фильтр по категории
     detailed: z.coerce.boolean().optional().default(false), // Флаг для детализации (группировка по name, size, grower)
 });
 

package/commands/report/export-inventory-turnover.query.ts

@@ -5,7 +5,7 @@ const ExportInventoryTurnoverRequestSchema = z
     .object({
         startDate: z.coerce.date().optional(),
         endDate: z.coerce.date().optional(),
-        categoryUUID: z.string().uuid().optional(), // Фильтр по категории
+        categoryUUID: z.uuid().optional(), // Фильтр по категории
         detailed: z.coerce.boolean().optional().default(false), // Флаг для детализации
     })
     .refine(

package/commands/report/export-sales-revenue.query.ts

@@ -6,7 +6,7 @@ const ExportSalesRevenueRequestSchema = z
     .object({
         startDate: z.coerce.date().optional(),
         endDate: z.coerce.date().optional(),
-        periodType: z.nativeEnum(ReportPeriodTypeEnum).default(ReportPeriodTypeEnum.DAY),
+        periodType: z.enum(ReportPeriodTypeEnum).default(ReportPeriodTypeEnum.DAY),
     })
     .refine(
         value => {

package/commands/transaction/apply-prepayment-transaction.command.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { TransactionSchema } from '../../schemas';
 
 const ApplyPrepaymentTransactionRequestSchema = z.object({
-    orderUUID: z.string().uuid().optional(),
+    orderUUID: z.uuid().optional(),
 });
 
 const ApplyPrepaymentTransactionResponseSchema = z.object({

package/commands/transaction/export-transactions.command.ts

@@ -6,7 +6,7 @@ const ExportTransactionsRequestSchema = z
     .object({
         startDate: z.coerce.date(),
         endDate: z.coerce.date(),
-        transactionType: z.nativeEnum(TransactionTypeEnum).optional(),
+        transactionType: z.enum(TransactionTypeEnum).optional(),
         moneyAccountUUID: z.string().optional(),
         clientUUID: z.string().optional(),
         orderUUID: z.string().optional(),

package/commands/transaction/get-transaction-list.query.ts

@@ -9,7 +9,7 @@ const GetTransactionListRequestSchema = z
         count: z.coerce.number().optional().default(10),
         startDate: z.coerce.date().optional(),
         endDate: z.coerce.date().optional(),
-        transactionType: z.nativeEnum(TransactionTypeEnum).optional(),
+        transactionType: z.enum(TransactionTypeEnum).optional(),
         moneyAccountUUID: z.string().optional(),
         clientUUID: z.string().optional(),
         orderUUID: z.string().optional(),

package/commands/transaction/get-transaction-summary.query.ts

@@ -6,7 +6,7 @@ const GetTransactionSummaryRequestSchema = z
     .object({
         startDate: z.coerce.date().optional(),
         endDate: z.coerce.date().optional(),
-        transactionType: z.nativeEnum(TransactionTypeEnum).optional(),
+        transactionType: z.enum(TransactionTypeEnum).optional(),
         moneyAccountUUID: z.string().optional(),
         clientUUID: z.string().optional(),
         orderUUID: z.string().optional(),

package/commands/transaction/webshop/get-transaction-list-for-client.query.ts

@@ -9,7 +9,7 @@ const GetTransactionListForClientRequestSchema = z
         count: z.coerce.number().optional().default(10),
         startDate: z.coerce.date().optional(),
         endDate: z.coerce.date().optional(),
-        transactionType: z.nativeEnum(TransactionTypeEnum).optional(),
+        transactionType: z.enum(TransactionTypeEnum).optional(),
         moneyAccountUUID: z.string().optional(),
         orderUUID: z.string().optional(),
         searchQuery: z.string().optional(),

package/commands/type/delete-type.command.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { DeleteDataResponseSchema } from '../../schemas/delete-data-response.schema';
 
 const DeleteTypeRequestSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
 });
 
 const DeleteTypeResponseSchema = z.object({

package/commands/type/get-type-by-uuid.query.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { TypeSchema } from '../../schemas/type/type.schema';
 
 const GetTypeByUUIDRequestSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
 });
 
 const GetTypeByUUIDResponseSchema = z.object({

package/commands/type/get-type-list.query.ts

@@ -5,7 +5,7 @@ import { OrderByEnum } from '../../enum/order-by.enum';
 const GetTypeListRequestSchema = z.object({
     page: z.string().transform(val => Number(val) || 1),
     count: z.string().transform(val => Number(val) || 10),
-    orderBy: z.nativeEnum(OrderByEnum).optional().default(OrderByEnum.ASC),
+    orderBy: z.enum(OrderByEnum).optional().default(OrderByEnum.ASC),
 });
 
 export const TypeListSchemaWithTotal = z.object({