@floristcloud/api-lib 1.0.19 → 1.0.21

package/commands/user/createUserByClientId.command.ts

@@ -7,14 +7,14 @@ const CreateUserByClientIdRequestSchema = z.object({
         .object({
             password: z.string(),
             name: z.string(),
-            email: z.string().email().toLowerCase().nullable().optional(),
+            email: z.email().toLowerCase().nullable().optional(),
             phone: z.string().nullable().optional(),
-            roles: z.array(z.nativeEnum(UserRoleEnum)).optional().default([UserRoleEnum.BUYER]),
+            roles: z.array(z.enum(UserRoleEnum)).optional().default([UserRoleEnum.BUYER]),
         })
         .refine(data => data.email || data.phone, {
             message: 'Either email or phone must be provided',
         }),
-    clientUuid: z.string().uuid(),
+    clientUuid: z.uuid(),
 });
 
 const CreateUserByClientIdResponseSchema = z.object({

package/commands/user/createUserForCompany.command.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { UserSchema } from '../../schemas';
 import { UserRoleEnum } from '../../enum';
 
-const UserRoles = z.nativeEnum(UserRoleEnum);
+const UserRoles = z.enum(UserRoleEnum);
 const AllowedRoles = UserRoles.refine(role => role !== UserRoleEnum.BUYER, {
     message: 'Allowed roles are: Admin, Manager, Employee',
 });

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

@@ -7,8 +7,8 @@ const GetUserListRequestSchema = z.object({
     page: z.coerce.number().optional().default(1),
     count: z.coerce.number().optional().default(10),
     searchQuery: z.string().optional().nullable().default(null),
-    orderBy: z.nativeEnum(OrderByEnum).default(OrderByEnum.ASC),
-    roles: z.array(z.nativeEnum(UserRoleEnum)).optional().nullable().default(null),
+    orderBy: z.enum(OrderByEnum).default(OrderByEnum.ASC),
+    roles: z.array(z.enum(UserRoleEnum)).optional().nullable().default(null),
 });
 
 const GetUserListResponseSchema = z.object({

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

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { UserSchema } from '../../schemas';
 
 const UpdateUserRequestSchema = z.object({
-    email: z.string().email().toLowerCase().nullable().optional(),
+    email: z.email().toLowerCase().nullable().optional(),
     name: z.string().optional(),
     phone: z.string().nullable().optional(),
 });

package/commands/wrire-off-archive/create-wrire-off-archive.command.ts

@@ -7,7 +7,7 @@ const CreateWriteOffArchiveResponseSchema = z.object({
     message: z.string().optional(),
     data: z
         .object({
-            status: z.nativeEnum(ConsignmentWriteOffArchivesStatusEnum),
+            status: z.enum(ConsignmentWriteOffArchivesStatusEnum),
             url: z.string().nullable().optional(),
         })
         .nullable(),

package/commands/wrire-off-archive/info-wrire-off-archive.command.ts

@@ -7,7 +7,7 @@ const InfoWriteOffArchiveResponseSchema = z.object({
     message: z.string().optional(),
     data: z
         .object({
-            status: z.nativeEnum(ConsignmentWriteOffArchivesStatusEnum),
+            status: z.enum(ConsignmentWriteOffArchivesStatusEnum),
             url: z.string().nullable().optional(),
         })
         .nullable(),

package/commands/write-off/get-write-off-list.query.ts

@@ -10,7 +10,7 @@ const GetWriteOffListRequestSchema = z.object({
     clientUUID: z.string().optional(),
     searchQuery: z.string().optional(),
     responsibleUserUUID: z.string().optional(),
-    status: z.nativeEnum(WriteOffStatusEnum).optional(),
+    status: z.enum(WriteOffStatusEnum).optional(),
     page: z.coerce.number().optional().default(1),
     count: z.coerce.number().optional().default(10),
 });

package/constant/error.ts

@@ -205,6 +205,8 @@ export const ERRORS = {
         httpCode: 400,
     },
     PRODUCT_MULTIPLICITY_OPTION_NOT_FOUND: { code: 'P017', message: 'Product multiplicity option not found', httpCode: 404 },
+    PRODUCT_MULTIPLICITY_OPTION_USED_IN_ORDER: { code: 'P018', message: 'Product multiplicity option used in order', httpCode: 400 },
+    PRODUCT_MULTIPLICITY_OPTION_NOT_DELETED: { code: 'P019', message: 'Failed to delete product multiplicity option', httpCode: 500 },
 
     // PRODUCT CONFIGURATION
     PRODUCT_CONFIGURATION_NOT_CREATED: { code: 'PCFG001', message: 'Failed to create product configuration', httpCode: 500 },
@@ -715,6 +717,16 @@ export const ERRORS = {
         httpCode: 400,
     },
     PRE_ORDER_COLLECTION_ITEM_EXPORT_FAILED: { code: 'POCI017', message: 'Failed to export pre order collection item', httpCode: 500 },
+    PRE_ORDER_COLLECTION_ITEM_MULTIPLICITY_OPTION_USED_IN_PRE_ORDER: {
+        code: 'POCI018',
+        message: 'Multiplicity option used in pre order',
+        httpCode: 400,
+    },
+    PRE_ORDER_COLLECTION_ITEM_MULTIPLICITY_OPTION_NOT_DELETED: {
+        code: 'POCI019',
+        message: 'Failed to delete multiplicity option',
+        httpCode: 500,
+    },
 
     // EMPLOYEE SCHEDULE
     EMPLOYEE_SCHEDULE_NOT_CREATED: { code: 'ES001', message: 'Failed to create employee schedule', httpCode: 500 },

package/enum/index.ts

@@ -26,6 +26,8 @@ export * from './discount-rules-type.enum';
 export * from './discount-rules-mode-type.enum';
 export * from './order-distribute-status-list';
 export * from './order-active-status-list';
+export * from './client-status.enum';
+export * from './client-type.enum';
 export * from './consignment-distribution-validation-status.enum';
 export * from './consignment-distribution-validation-type.enum';
 export * from './consignment-access-client-status.enum';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@floristcloud/api-lib",
-    "version": "1.0.19",
+    "version": "1.0.21",
     "description": "",
     "main": "./build/index.js",
     "scripts": {

package/schemas/action-log/action-log.schema.ts

@@ -96,7 +96,7 @@ export const ActionLogSchema = z.discriminatedUnion('actionType', [
 ]);
 
 export const CreateActionLogSchema = z.object({
-    actionType: z.nativeEnum(ActionLogTypeEnum),
+    actionType: z.enum(ActionLogTypeEnum),
     entityUUID: z.string(),
 });
 

package/schemas/action-log/order-update-action-log.schema.ts

@@ -2,6 +2,6 @@ import { z } from 'zod';
 import { OrderStatusEnum } from '../../enum';
 
 export const OrderUpdateActionLogSchema = z.object({
-    oldStatus: z.nativeEnum(OrderStatusEnum),
-    newStatus: z.nativeEnum(OrderStatusEnum),
+    oldStatus: z.enum(OrderStatusEnum),
+    newStatus: z.enum(OrderStatusEnum),
 });

package/schemas/action-log/transaction-info.schema.ts

@@ -6,6 +6,6 @@ export const TransactionInfoSchema = z.object({
     createdAt: z.coerce.date(),
     amount: z.coerce.number(),
     moneyAccountName: z.string(),
-    type: z.nativeEnum(TransactionTypeEnum),
+    type: z.enum(TransactionTypeEnum),
     clientName: z.string().nullable(),
 });

package/schemas/bank-payment/bank-payment.schema.ts

@@ -3,22 +3,22 @@ import { BankProviderEnum } from '../../enum/bank-provider.enum';
 import { BankPaymentEventStatusEnum } from '../../enum/bank-payment-event-status.enum';
 
 export const BankPaymentSchema = z.object({
-    uuid: z.string().uuid(),
-    provider: z.nativeEnum(BankProviderEnum),
+    uuid: z.uuid(),
+    provider: z.enum(BankProviderEnum),
     externalEventId: z.string(),
     accountNumber: z.string(),
     amount: z.coerce.number(),
     currency: z.string(),
     purpose: z.string(),
-    status: z.nativeEnum(BankPaymentEventStatusEnum),
+    status: z.enum(BankPaymentEventStatusEnum),
     docNumber: z.string().nullable(),
     clientName: z.string().nullable(),
     clientInn: z.string().nullable(),
     valueDate: z.coerce.date(),
-    clientUUID: z.string().uuid().nullable(),
-    moneyAccountUUID: z.string().uuid().nullable(),
+    clientUUID: z.uuid().nullable(),
+    moneyAccountUUID: z.uuid().nullable(),
     moneyAccountName: z.string().nullable(),
     payload: z.unknown(),
-    appliedTransactionUUID: z.string().uuid().nullable(),
+    appliedTransactionUUID: z.uuid().nullable(),
     receivedAt: z.coerce.date(),
 });

package/schemas/branch/branch.schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 export const BranchSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     contactName: z.string().nullable(),
     contactPhone: z.string().nullable(),
@@ -9,7 +9,7 @@ export const BranchSchema = z.object({
     city: z.string().nullable(),
     region: z.string().nullable(),
     country: z.string().nullable(),
-    clientId: z.string().uuid(),
+    clientId: z.uuid(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/schemas/category/category.schema.ts

@@ -3,12 +3,12 @@ import { CategoryStatusEnum } from '../../enum/category-status.enum';
 import { TypeSchema } from '../type/type.schema';
 
 export const CategorySchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     multiplicity: z.number().nullable(),
     isSizeSeparate: z.boolean(),
     isSaveCategoryName: z.boolean(),
-    status: z.nativeEnum(CategoryStatusEnum),
+    status: z.enum(CategoryStatusEnum),
     createdAt: z.date(),
     updatedAt: z.date(),
     deletedAt: z.date().nullable(),

package/schemas/category-alias/category-alias.schema.ts

@@ -1,16 +1,16 @@
 import { z } from 'zod';
 
 export const CategoryAliasSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
-    companyUUID: z.string().uuid(),
-    categoryUUID: z.string().uuid(),
+    companyUUID: z.uuid(),
+    categoryUUID: z.uuid(),
     deletedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),
 });
 
 export const AliasInListSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
 });

package/schemas/category-template/category-template.schema.ts

@@ -7,11 +7,11 @@ export const CategoryTemplateTypeSchema = z.object({
 });
 
 export const CategoryTemplateSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     alias: z.string().array(),
     type: CategoryTemplateTypeSchema,
-    language: z.nativeEnum(LanguageEnum),
+    language: z.enum(LanguageEnum),
     deletedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),

package/schemas/client/client-debt.schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 export const ClientDebtItemSchema = z.object({
-    clientUUID: z.string().uuid(),
+    clientUUID: z.uuid(),
     name: z.string(),
     code: z.string().nullable(),
     group: z.string().nullable(),

package/schemas/client/client-individual-profile.schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 export const ClientIndividualProfileSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     firstName: z.string().nullable(),
     lastName: z.string().nullable(),
     middleName: z.string().nullable(),

package/schemas/client/client-legal-profile.schema.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { ClientLegalTypeEnum } from '../../enum';
 
 export const ClientLegalProfileSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     fullCompanyName: z.string().nullable(),
     taxId: z.string().nullable(),
     ogrn: z.string().nullable(),
@@ -17,7 +17,7 @@ export const ClientLegalProfileSchema = z.object({
     edoUsage: z.boolean(),
     edoId: z.string().nullable(),
     address: z.string().nullable(),
-    legalType: z.nativeEnum(ClientLegalTypeEnum),
+    legalType: z.enum(ClientLegalTypeEnum),
     createdAt: z.date(),
     updatedAt: z.date(),
 });

package/schemas/client/client-marking.schema.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 
 export const ClientMarkingSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
 });

package/schemas/client/client.schema.ts

@@ -8,12 +8,12 @@ import { DiscountRulesSchema } from '../discount-rules/discount-rules.schema';
 import { ClientMarkingSchema } from './client-marking.schema';
 
 export const ClientSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     contactName: z.string().nullable(),
     phone: z.string().nullable(),
     email: z.string().nullable(),
-    status: z.nativeEnum(ClientStatusEnum),
+    status: z.enum(ClientStatusEnum),
     isCommon: z.boolean(),
     contractNumber: z.string().nullable(),
     contractDate: z.date().nullable(),
@@ -31,10 +31,10 @@ export const ClientSchema = z.object({
     deletedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),
-    companyUUID: z.string().uuid(),
+    companyUUID: z.uuid(),
 
-    clientType: z.nativeEnum(ClientTypeEnum),
-    responsibleUserUUID: z.string().uuid().nullable(),
+    clientType: z.enum(ClientTypeEnum),
+    responsibleUserUUID: z.uuid().nullable(),
     responsibleSince: z.date().nullable(),
 });
 

package/schemas/company/company.schema.ts

@@ -2,10 +2,10 @@ import { z } from 'zod';
 import { CompanyStatusEnum } from '../../enum/companyStatus.enum';
 
 export const CompanySchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     alias: z.string(),
-    status: z.nativeEnum(CompanyStatusEnum),
+    status: z.enum(CompanyStatusEnum),
     deletedAt: z.date().nullable(),
     createdAt: z.date(),
     updatedAt: z.date(),

package/schemas/consignment/consignment-distribution-validation.schema.ts

@@ -6,14 +6,14 @@ import { OrderProductExtendedSchema } from '../order-product/order-product.schem
 export const ValidationProductSchema = z.object({
     type: z.literal(ConsignmentDistributionValidationTypeEnum.PACKAGE),
     product: ProductSchema,
-    status: z.nativeEnum(ConsignmentDistributionValidationStatusEnum),
+    status: z.enum(ConsignmentDistributionValidationStatusEnum),
     quantity: z.number(),
 });
 
 export const ValidationDistributionSchema = z.object({
     type: z.literal(ConsignmentDistributionValidationTypeEnum.DISTRIBUTION),
     orderProduct: OrderProductExtendedSchema,
-    status: z.nativeEnum(ConsignmentDistributionValidationStatusEnum),
+    status: z.enum(ConsignmentDistributionValidationStatusEnum),
     quantity: z.number(),
 });
 

package/schemas/consignment/consignment.schema.ts

@@ -3,7 +3,7 @@ import { ConsignmentImportSchemaRelationEntityPropertyEnum, ConsignmentStatusEnu
 import { ClientSchema } from '../client';
 
 export const ConsignmentSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     deliveryDate: z.date(),
     id: z.number(),
     deliveryTime: z.string().nullable(),
@@ -11,7 +11,7 @@ export const ConsignmentSchema = z.object({
     description: z.string().nullable(),
     label: z.string().nullable(),
     isInStock: z.boolean(),
-    status: z.nativeEnum(ConsignmentStatusEnum),
+    status: z.enum(ConsignmentStatusEnum),
     url: z.string().nullable(),
     isWithSync: z.boolean(),
     createdAt: z.date(),
@@ -44,7 +44,7 @@ export const ConsignmentWithStatisticSchema = ConsignmentSchema.extend({
 
 export const ProductErrorTypeSchema = z.object({
     row: z.number().optional(),
-    path: z.nativeEnum(ConsignmentImportSchemaRelationEntityPropertyEnum).optional(),
+    path: z.enum(ConsignmentImportSchemaRelationEntityPropertyEnum).optional(),
     type: z.union([z.literal(ConsingmentImportErrorsEnum.REQUIRED), z.literal(ConsingmentImportErrorsEnum.INVALID_VALUE)]),
 });
 

package/schemas/consignment-import-schema/consignment-import-schema.scheme.ts

@@ -2,10 +2,10 @@ import { z } from 'zod';
 import { ConsignmentImportSchemaRelationSchema } from '../consignment-import-schema-relation/consignment-import-schema-relation.schema';
 
 export const ConsignmentImportSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     isDefault: z.boolean(),
-    companyUUID: z.string().uuid(),
+    companyUUID: z.uuid(),
 });
 
 export const ConsignmentImportSchemaExtendedSchema = ConsignmentImportSchema.merge(

package/schemas/consignment-import-schema-relation/consignment-import-schema-relation.schema.ts

@@ -2,9 +2,9 @@ import { z } from 'zod';
 import { ConsignmentImportSchemaRelationEntityPropertyEnum } from '../../enum';
 
 export const ConsignmentImportSchemaRelationSchema = z.object({
-    uuid: z.string().uuid(),
-    entityProperty: z.nativeEnum(ConsignmentImportSchemaRelationEntityPropertyEnum),
+    uuid: z.uuid(),
+    entityProperty: z.enum(ConsignmentImportSchemaRelationEntityPropertyEnum),
     externalName: z.string(),
     isRequire: z.boolean(),
-    consignmentImportSchemaUUID: z.string().uuid(),
+    consignmentImportSchemaUUID: z.uuid(),
 });

package/schemas/delivery-route/delivery-route.schema.ts

@@ -2,12 +2,12 @@ import { z } from 'zod';
 import { DeliveryRouteStatusEnum, OrderDeliveryStatusEnum, OrderStatusEnum } from '../../enum';
 
 export const DeliveryRouteSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     routeName: z.string().nullable(),
     driverName: z.string().nullable(),
     driverPhone: z.string().nullable(),
     comment: z.string().nullable(),
-    status: z.nativeEnum(DeliveryRouteStatusEnum),
+    status: z.enum(DeliveryRouteStatusEnum),
     date: z.coerce.date(),
     createdAt: z.coerce.date(),
     updatedAt: z.coerce.date(),
@@ -30,9 +30,9 @@ export const UpdateDeliveryRouteSchema = DeliveryRouteSchema.omit({
 export const DeliveryRouteWithOrdersSchema = DeliveryRouteSchema.extend({
     orders: z.array(
         z.object({
-            uuid: z.string().uuid(),
+            uuid: z.uuid(),
             orderNumber: z.number(),
-            orderStatus: z.nativeEnum(OrderStatusEnum),
+            orderStatus: z.enum(OrderStatusEnum),
             orderCreatedAt: z.coerce.date(),
             totalCost: z.number(),
             clientName: z.string(),
@@ -41,8 +41,8 @@ export const DeliveryRouteWithOrdersSchema = DeliveryRouteSchema.extend({
             clientPhone: z.string().nullable(),
             clientCode: z.string().nullable(),
             clientGroup: z.string().nullable(),
-            orderDeliveryUUID: z.string().uuid().nullable(),
-            orderDeliveryStatus: z.nativeEnum(OrderDeliveryStatusEnum).nullable(),
+            orderDeliveryUUID: z.uuid().nullable(),
+            orderDeliveryStatus: z.enum(OrderDeliveryStatusEnum).nullable(),
             deliveryAddress: z.string().nullable(),
             deliveryComment: z.string().nullable(),
             consignmentDates: z.array(z.coerce.date()),

package/schemas/domain/domain.schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 export const DomainSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     companyId: z.string(),
     createdAt: z.date(),

package/schemas/message/client-inbox-item.schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 export const ClientInboxItemSchema = z.object({
-    clientUUID: z.string().uuid(),
+    clientUUID: z.uuid(),
     clientName: z.string(),
     clientCode: z.string().nullable(),
     clientGroup: z.string().nullable(),

package/schemas/message/context-inbox.schema.ts

@@ -2,16 +2,16 @@ import { z } from 'zod';
 import { ContextMessageContextTypeEnum } from '../../enum/context-message-context-type.enum';
 
 export const ContextInboxItemSchema = z.object({
-    contextType: z.nativeEnum(ContextMessageContextTypeEnum),
-    contextUUID: z.string().uuid(),
-    subjectUUID: z.string().uuid().nullable().optional(),
+    contextType: z.enum(ContextMessageContextTypeEnum),
+    contextUUID: z.uuid(),
+    subjectUUID: z.uuid().nullable().optional(),
     lastMessageAt: z.date(),
     lastMessagePreview: z.string().nullable(),
     lastMessageIsFromClient: z.boolean(),
     unreadCount: z.number(),
 
     orderId: z.number().nullable().optional(),
-    orderUUID: z.string().uuid().nullable().optional(),
+    orderUUID: z.uuid().nullable().optional(),
     clientName: z.string().nullable().optional(),
     productName: z.string().nullable().optional(),
 });

package/schemas/message/context-message.schema.ts

@@ -2,14 +2,14 @@ import { z } from 'zod';
 import { ContextMessageContextTypeEnum } from '../../enum/context-message-context-type.enum';
 
 export const ContextMessageSchema = z.object({
-    uuid: z.string().uuid(),
-    contextType: z.nativeEnum(ContextMessageContextTypeEnum),
-    contextUUID: z.string().uuid(),
-    subjectUUID: z.string().uuid().nullable().optional(),
+    uuid: z.uuid(),
+    contextType: z.enum(ContextMessageContextTypeEnum),
+    contextUUID: z.uuid(),
+    subjectUUID: z.uuid().nullable().optional(),
 
     isFromClient: z.boolean(),
-    authorUserUUID: z.string().uuid().nullable(),
-    authorClientUUID: z.string().uuid().nullable(),
+    authorUserUUID: z.uuid().nullable(),
+    authorClientUUID: z.uuid().nullable(),
 
     text: z.string(),
     payload: z.any().nullable().optional(),

package/schemas/money-account/money-account.schema.ts

@@ -3,11 +3,11 @@ import { MoneyAccountStatusEnum } from '../../enum/money-account-status.enum';
 import { UserRoleEnum } from '../../enum';
 
 export const MoneyAccountSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     name: z.string(),
     companyUUID: z.string(),
-    roles: z.nativeEnum(UserRoleEnum).array(),
-    status: z.nativeEnum(MoneyAccountStatusEnum),
+    roles: z.enum(UserRoleEnum).array(),
+    status: z.enum(MoneyAccountStatusEnum),
     createdAt: z.date(),
     updatedAt: z.date(),
     deletedAt: z.date().nullable(),

package/schemas/order/order.schema.ts

@@ -6,11 +6,11 @@ import { OrderDeliverySchema } from '../order-delivery/order-delivery.schema';
 import { DeliveryRouteSchema } from '../delivery-route/delivery-route.schema';
 
 export const OrderSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     orderNumber: z.number(),
-    clientUUID: z.string().uuid(),
-    branchUUID: z.string().uuid().nullable(),
-    creatorUserUUID: z.string().uuid(),
+    clientUUID: z.uuid(),
+    branchUUID: z.uuid().nullable(),
+    creatorUserUUID: z.uuid(),
 
     isSync: z.boolean(),
     totalCost: z.number(),
@@ -23,8 +23,8 @@ export const OrderSchema = z.object({
     discountAmount: z.number(),
     discount: z.number().nullable(),
 
-    status: z.nativeEnum(OrderStatusEnum),
-    type: z.nativeEnum(OrderTypeEnum),
+    status: z.enum(OrderStatusEnum),
+    type: z.enum(OrderTypeEnum),
     isPaid: z.boolean(),
 
     comment: z.string().nullable(),
@@ -34,7 +34,7 @@ export const OrderSchema = z.object({
     totalQuantity: z.number(),
     totalProductNumber: z.number(),
     invoiceSendAt: z.date().nullable(),
-    deliveryRouteUUID: z.string().uuid().nullable(),
+    deliveryRouteUUID: z.uuid().nullable(),
 
     completedAt: z.date().nullable(),
     paymentDueAt: z.date().nullable(),

package/schemas/order-delivery/order-delivery.schema.ts

@@ -2,11 +2,11 @@ import { z } from 'zod';
 import { OrderDeliveryStatusEnum } from '../../enum';
 
 export const OrderDeliverySchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     city: z.string().nullable(),
     deliveryDate: z.coerce.date().nullable(),
     address: z.string().nullable(),
     time: z.string().nullable(),
     comment: z.string().nullable(),
-    orderDeliveryStatus: z.nativeEnum(OrderDeliveryStatusEnum),
+    orderDeliveryStatus: z.enum(OrderDeliveryStatusEnum),
 });

package/schemas/order-product/order-product-multiplicity-optiom.schema.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 
 export const OrderProductMultiplicityOptionSchema = z.object({
-    uuid: z.string().uuid(),
+    uuid: z.uuid(),
     title: z.string().nullable(),
     optionMultiplicity: z.coerce.number(),
     optionPrice: z.coerce.number().nullable(),

package/schemas/order-product/order-product.schema.ts

@@ -7,10 +7,10 @@ import { DistributionSchema } from '../distribution/distribution.schema';
 import { OrderProductMultiplicityOptionSchema } from './order-product-multiplicity-optiom.schema';
 
 export const OrderProductSchema = z.object({
-    uuid: z.string().uuid(),
-    productUUID: z.string().uuid(),
-    orderUUID: z.string().uuid(),
-    multiplicityOptionUUID: z.string().uuid().nullable().optional(),
+    uuid: z.uuid(),
+    productUUID: z.uuid(),
+    orderUUID: z.uuid(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
 
     quantity: z.number(),
     price: z.number(),
@@ -47,7 +47,7 @@ export const OrderProductExtendedSchema = OrderProductSchema.extend({
 
 export const OrderProductForClientExtendedSchema = OrderProductForClientSchema.extend({
     product: ProductExtendedForClientSchema,
-    multiplicityOptionUUID: z.string().uuid().nullable().optional(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
 });
 
 export const OrderProductForDistributeSchema = OrderProductSchema.extend({