@floristcloud/api-lib 1.2.108 → 1.2.110

package/build/schemas/transaction/transaction.schema.js

@@ -6,10 +6,11 @@ const enum_1 = require("../../enum");
 const money_account_schema_1 = require("../money-account/money-account.schema");
 const client_1 = require("../client");
 const order_schema_1 = require("../order/order.schema");
+const money_schema_1 = require("../money.schema");
 exports.TransactionSchema = zod_1.z.object({
     uuid: zod_1.z.uuid(),
     moneyAccountUUID: zod_1.z.uuid(),
-    amount: zod_1.z.number(),
+    amount: money_schema_1.MoneySchema,
     comment: zod_1.z.string(),
     clientUUID: zod_1.z.string().nullable(),
     orderUUID: zod_1.z.string().nullable(),

package/commands/client/get-client-calculate.query.ts

@@ -1,12 +1,14 @@
 import { z } from 'zod';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const GetClientCalculateResponseSchema = z.object({
     message: z.string().optional(),
     data: z.object({
-        transactionSum: z.number(),
-        ordersSum: z.number(),
-        writeOffSum: z.number(),
-        calculation: z.number(),
+        transactionSum: MoneySchema,
+        ordersSum: MoneySchema,
+        writeOffSum: MoneySchema,
+        // Сальдо по клиенту: может быть отрицательным, поэтому знаковых ограничений нет.
+        calculation: MoneySchema,
     }),
 });
 

package/commands/consignment/execute-consignment-product-update.command.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import { ErrorMessageSchema } from '../../schemas/error-message.schema';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const OptionUpdateSchema = z.object({
     title: z.string().nullable().optional(),
     optionMultiplicity: z.number().nullable().optional(),
-    optionPrice: z.number().nullable().optional(),
+    optionPrice: MoneySchema.nullable().optional(),
 });
 
 const ConsignmentProductPositionUpdateSchema = z.object({
@@ -12,9 +13,9 @@ const ConsignmentProductPositionUpdateSchema = z.object({
     multiplicity: z.number().nullable().optional(),
     quantity: z.number().nullable().optional(),
     balance: z.number().nullable().optional(),
-    price: z.number().nullable().optional(),
-    costPrice: z.number().nullable().optional(),
-    invoicePrice: z.number().nullable().optional(),
+    price: MoneySchema.nullable().optional(),
+    costPrice: MoneySchema.nullable().optional(),
+    invoicePrice: MoneySchema.nullable().optional(),
     invoiceNumber: z.string().nullable().optional(),
     multiplicityDescription: z.string().nullable().optional(),
     vat: z.number().nullable().optional(),

package/commands/integration/moysklad/execute-moysklad-import.command.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { SalesUnitEnum } from '../../../enum';
+import { MoneySchema } from '../../../schemas/money.schema';
 
 const ExecutableItemSchema = z.object({
     externalSourceId: z.string(),
@@ -11,8 +12,8 @@ const ExecutableItemSchema = z.object({
     color: z.string().nullable(),
     country: z.string().nullable(),
     grower: z.string().nullable(),
-    price: z.number(),
-    costPrice: z.number(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
     balance: z.number(),
     vat: z.number().nullable(),
     salesUnit: z.nativeEnum(SalesUnitEnum),

package/commands/integration/moysklad/preview-moysklad-products.query.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { MoneySchema } from '../../../schemas/money.schema';
 
 const PreviewMoyskladProductsRequestSchema = z.object({
     limit: z.coerce.number().int().min(1).max(100).default(20),
@@ -13,8 +14,8 @@ const MappedProductPreviewSchema = z.object({
     color: z.string().nullable(),
     country: z.string().nullable(),
     grower: z.string().nullable(),
-    price: z.number(),
-    costPrice: z.number(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
     balance: z.number(),
     categoryName: z.string().nullable(),
 });

package/commands/integration/moysklad/scan-moysklad-import.query.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { SalesUnitEnum } from '../../../enum';
+import { MoneySchema } from '../../../schemas/money.schema';
 
 const ScannedItemSchema = z.object({
     externalSourceId: z.string(),
@@ -13,8 +14,8 @@ const ScannedItemSchema = z.object({
     color: z.string().nullable(),
     country: z.string().nullable(),
     grower: z.string().nullable(),
-    price: z.number(),
-    costPrice: z.number(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
     balance: z.number(),
     categoryName: z.string().nullable(),
     vat: z.number().nullable(),

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

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

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

@@ -1,11 +1,12 @@
 import { z } from 'zod';
 import { OrderStatusEnum, OrderTypeEnum } from '../../enum';
 import { OrderSchema } from '../../schemas';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const UpdateOrderRequestSchema = z.object({
     clientUUID: z.uuid(),
     branchUUID: z.uuid().nullable(),
-    deliveryCost: z.coerce.number(),
+    deliveryCost: MoneySchema,
     type: z.nativeEnum(OrderTypeEnum),
     comment: z.string().nullable(),
     clientComment: z.string().nullable(),
@@ -13,7 +14,7 @@ const UpdateOrderRequestSchema = z.object({
     status: z.nativeEnum(OrderStatusEnum),
     isPaid: z.coerce.boolean(),
     deliveryVat: z.coerce.number().nullable(),
-    deliveryVatAmount: z.coerce.number(),
+    deliveryVatAmount: MoneySchema,
     completedAt: z.coerce.date().nullable().optional(),
     paymentDueAt: z.coerce.date().nullable().optional(),
 });

package/commands/order/webshop/get-order-sales-by-month.query.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { MoneySchema } from '../../../schemas/money.schema';
+import { NonNegativeMoneySchema } from '../../../schemas/non-negative-money.schema';
 
 const GetOrderSalesByMonthRequestSchema = z.object({
     month: z.coerce.number().int().min(1).max(12),
@@ -6,7 +8,7 @@ const GetOrderSalesByMonthRequestSchema = z.object({
 
 const GetOrderSalesByMonthResponseSchema = z.object({
     message: z.string().optional(),
-    data: z.number(),
+    data: NonNegativeMoneySchema,
 });
 
 export namespace GetOrderSalesByMonthContractQuery {

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

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { OrderProductSchema } from '../../schemas';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const CreateOrderProductRequestSchema = z.object({
     quantity: z.number(),
-    price: z.number(),
+    price: MoneySchema,
     comment: z.string().nullable(),
     tag: z.string().nullable(),
     isEditable: z.coerce.boolean(),

package/commands/order-product/group/price-valuation-execute.command.ts

@@ -1,11 +1,14 @@
 import { z } from 'zod';
 import { PriceCorrectionExecuteResultItemSchema } from '../../../schemas';
+import { MoneySchema } from '../../../schemas/money.schema';
+import { NonNegativeMoneySchema } from '../../../schemas/non-negative-money.schema';
 
 const PRICE_VALUATION_BATCH_LIMIT = 50;
 
 const PriceValuationExecuteItemSchema = z.object({
     orderProductUUID: z.string().uuid(),
-    price: z.number().nonnegative(),
+    // Неотрицательность проверяем по знаку строки: минус — единственный признак отрицательной суммы.
+    price: NonNegativeMoneySchema,
 });
 
 const PriceValuationExecuteRequestSchema = z.object({

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

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import { OrderProductSchema } from '../../schemas';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const UpdateOrderProductRequestSchema = z.object({
     productUUID: z.uuid(),
     quantity: z.number(),
-    price: z.number(),
+    price: MoneySchema,
     comment: z.string().nullable(),
     tag: z.string().nullable(),
     isEditable: z.coerce.boolean(),

package/commands/payment-invoice/create-payment-invoice.command.ts

@@ -1,5 +1,7 @@
 import { z } from 'zod';
 import { PaymentInvoiceSchema } from '../../schemas/payment-invoice/payment-invoice.schema';
+import { MoneySchema } from '../../schemas/money.schema';
+import { PositiveMoneySchema } from '../../schemas/positive-money.schema';
 
 // Потолок числа заказов в счёте. Это защита от абсурдного запроса, а не бизнес-правило: счёт за месяц
 // клиенту с ежедневными поставками — это уже 30 строк, поэтому 10-20 отрезали бы живые сценарии.
@@ -15,7 +17,8 @@ const CreatePaymentInvoiceRequestSchema = z
         clientUUID: z.uuid(),
         invoiceDate: z.coerce.date(),
         orderUUIDs: z.uuid().array().max(MAX_INVOICE_ORDER_COUNT).optional(),
-        amount: z.coerce.number().positive().optional(),
+        // Строго положительная сумма: отсекаем минус по знаку строки и нулевые записи вида "0" / "0.00".
+        amount: PositiveMoneySchema.optional(),
     })
     .refine(value => Boolean(value.orderUUIDs?.length) || value.amount !== undefined, {
         message: 'Either orderUUIDs or amount must be provided',

package/commands/payment-invoice/pay-payment-invoice.command.ts

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 import { PaymentInvoiceSchema } from '../../schemas/payment-invoice/payment-invoice.schema';
+import { MoneySchema } from '../../schemas/money.schema';
+import { PositiveMoneySchema } from '../../schemas/positive-money.schema';
 
 // Оплата по счёту. amount не передан — гасим остаток целиком; передан — частичная оплата.
 const PayPaymentInvoiceRequestSchema = z.object({
     moneyAccountUUID: z.uuid(),
-    amount: z.coerce.number().positive().optional(),
+    // Строго положительная сумма: отсекаем минус по знаку строки и нулевые записи вида "0" / "0.00".
+    amount: PositiveMoneySchema.optional(),
     comment: z.string().optional(),
     cashFlowItemUUID: z.uuid().nullable().optional(),
     createdAt: z.coerce.date().optional(),

package/commands/pre-order-collection-item/execute-pre-order-collection-item-update.command.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import { ErrorMessageSchema } from '../../schemas/error-message.schema';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const OptionUpdateSchema = z.object({
     title: z.string().nullable().optional(),
     optionMultiplicity: z.number().nullable().optional(),
-    optionPrice: z.number().nullable().optional(),
+    optionPrice: MoneySchema.nullable().optional(),
 });
 
 const PositionUpdateSchema = z.object({
@@ -12,7 +13,7 @@ const PositionUpdateSchema = z.object({
     multiplicity: z.number().nullable().optional(),
     quantity: z.number().nullable().optional(),
     balance: z.number().nullable().optional(),
-    price: z.number().nullable().optional(),
+    price: MoneySchema.nullable().optional(),
     advancedPrice: z.string().nullable().optional(),
     grower: z.string().nullable().optional(),
     size: z.string().nullable().optional(),

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

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { PreOrderCollectionItemMultiplicityOptionSchema } from '../../../schemas';
+import { MoneySchema } from '../../../schemas/money.schema';
+import { NonNegativeMoneySchema } from '../../../schemas/non-negative-money.schema';
 
 const CreatePreOrderCollectionItemMultiplicityOptionRequestSchema = z.object({
     title: z.string().max(100).nullable().optional(),
     optionMultiplicity: z.coerce.number().int().min(1),
-    optionPrice: z.coerce.number().min(0).nullable().optional(),
+    optionPrice: NonNegativeMoneySchema.nullable().optional(),
     rank: z.coerce.number().int().min(0).default(0).optional(),
 });
 

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

@@ -1,11 +1,13 @@
 import { z } from 'zod';
 import { PreOrderCollectionItemMultiplicityOptionSchema } from '../../../schemas';
+import { MoneySchema } from '../../../schemas/money.schema';
+import { NonNegativeMoneySchema } from '../../../schemas/non-negative-money.schema';
 
 const UpdatePreOrderCollectionItemMultiplicityOptionRequestSchema = z
     .object({
         title: z.string().max(100).nullable(),
         optionMultiplicity: z.coerce.number().int().min(1),
-        optionPrice: z.coerce.number().min(0).nullable(),
+        optionPrice: NonNegativeMoneySchema.nullable(),
         rank: z.coerce.number().int().min(0).default(0),
     })
     .partial();

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ProductMarkEnum, SalesUnitEnum } from '../../enum';
 import { ProductExtendedForAdminSchema } from '../../schemas';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const CreateProductRequestSchema = z.object({
     name: z.string(),
@@ -8,8 +9,8 @@ const CreateProductRequestSchema = z.object({
     categoryUUID: z.string(),
     balance: z.number(),
     quantity: z.number(),
-    price: z.number(),
-    costPrice: z.number(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
     multiplicity: z.number(),
     isOpen: z.coerce.boolean(),
 
@@ -20,7 +21,7 @@ const CreateProductRequestSchema = z.object({
     size: z.string().nullable(),
     size2: z.string().nullable(),
     size3: z.string().nullable(),
-    invoicePrice: z.number().nullable(),
+    invoicePrice: MoneySchema.nullable(),
     invoiceNumber: z.string().nullable(),
     imageUUID: z.string().nullable(),
     country: z.string().nullable(),

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

@@ -1,11 +1,12 @@
 import { z } from 'zod';
+import { MoneySchema } from '../../../schemas/money.schema';
 
 const UpdateGroupProductPricesRequestSchema = z.object({
     data: z
         .object({
             productUUID: z.string(),
-            newCost: z.coerce.number(),
-            newPrice: z.coerce.number().optional(),
+            newCost: MoneySchema,
+            newPrice: MoneySchema.optional(),
         })
         .array(),
 });

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { SalesUnitEnum } from '../../../enum';
 import { ErrorMessageSchema } from '../../../schemas/error-message.schema';
+import { MoneySchema } from '../../../schemas/money.schema';
 
 const UpdateGroupProductUpdateBatchRequestSchema = z.object({
     productUUIDList: z.array(z.string()),
@@ -8,15 +9,15 @@ const UpdateGroupProductUpdateBatchRequestSchema = z.object({
         .object({
             name: z.string(),
             categoryUUID: z.string(),
-            price: z.coerce.number(),
-            costPrice: z.coerce.number(),
+            price: MoneySchema,
+            costPrice: MoneySchema,
             color: z.string().nullable(),
             size: z.string().nullable(),
             multiplicity: z.coerce.number(),
             size2: z.string().nullable(),
             grower: z.string().nullable(),
             country: z.string().nullable(),
-            invoicePrice: z.coerce.number().nullable(),
+            invoicePrice: MoneySchema.nullable(),
             invoiceNumber: z.string().nullable(),
             imageUUID: z.string().nullable(),
             multiplicityDescription: z.string().nullable(),

package/commands/product/multiplicity-option/create-product-multiplicity-option.command.ts

@@ -1,10 +1,12 @@
 import { z } from 'zod';
 import { ProductMultiplicityOptionSchema } from '../../../schemas';
+import { MoneySchema } from '../../../schemas/money.schema';
+import { NonNegativeMoneySchema } from '../../../schemas/non-negative-money.schema';
 
 const CreateProductMultiplicityOptionRequestSchema = z.object({
     title: z.string().max(100).nullable().optional(),
     optionMultiplicity: z.coerce.number().int().min(1),
-    optionPrice: z.coerce.number().min(0).nullable().optional(),
+    optionPrice: NonNegativeMoneySchema.nullable().optional(),
     rank: z.coerce.number().int().min(0).default(0).optional(),
 });
 

package/commands/product/multiplicity-option/update-product-multiplicity-option.command.ts

@@ -1,11 +1,13 @@
 import { z } from 'zod';
 import { ProductMultiplicityOptionSchema } from '../../../schemas';
+import { MoneySchema } from '../../../schemas/money.schema';
+import { NonNegativeMoneySchema } from '../../../schemas/non-negative-money.schema';
 
 const UpdateProductMultiplicityOptionRequestSchema = z
     .object({
         title: z.string().max(100).nullable(),
         optionMultiplicity: z.coerce.number().int().min(1),
-        optionPrice: z.coerce.number().min(0).nullable(),
+        optionPrice: NonNegativeMoneySchema.nullable(),
         rank: z.coerce.number().int().min(0).default(0),
     })
     .partial();

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ProductMarkEnum, SalesUnitEnum } from '../../enum';
 import { ProductExtendedForAdminSchema } from '../../schemas';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const UpdateProductRequestSchema = z.object({
     name: z.string(),
@@ -8,8 +9,8 @@ const UpdateProductRequestSchema = z.object({
     categoryUUID: z.string(),
     balance: z.number(),
     quantity: z.number(),
-    price: z.number(),
-    costPrice: z.number(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
     multiplicity: z.number(),
     isOpen: z.coerce.boolean(),
 
@@ -20,7 +21,7 @@ const UpdateProductRequestSchema = z.object({
     size: z.string().nullable(),
     size2: z.string().nullable(),
     size3: z.string().nullable(),
-    invoicePrice: z.number().nullable(),
+    invoicePrice: MoneySchema.nullable(),
     invoiceNumber: z.string().nullable(),
     imageUUID: z.string().nullable(),
     country: z.string().nullable(),

package/commands/report/export-sales-by-client.query.ts

@@ -1,11 +1,14 @@
 import { z } from 'zod';
 import { dateRangeCheck, isStatementPeriodWithinLimit } from '../../helpers/date.helper';
+import { ReportOrderFilterSchema } from '../../schemas/report/report-order-filter.schema';
 
 const ExportSalesByClientRequestSchema = z
     .object({
         startDate: z.coerce.date(),
         endDate: z.coerce.date(),
     })
+    // dateBasis / excludeClientUUID — те же, что у JSON-эндпоинтов отчётов по заказам.
+    .merge(ReportOrderFilterSchema)
     .refine(value => dateRangeCheck(value.startDate, value.endDate), {
         message: 'validation.dateRange',
         path: ['endDate', 'startDate'],

package/commands/report/export-sales-by-position.query.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { dateRangeCheck, isStatementPeriodWithinLimit } from '../../helpers/date.helper';
 import { SalesByPositionGroupByEnum } from '../../enum/sales-by-position-group-by.enum';
+import { ReportOrderFilterSchema } from '../../schemas/report/report-order-filter.schema';
 
 const ExportSalesByPositionRequestSchema = z
     .object({
@@ -8,6 +9,8 @@ const ExportSalesByPositionRequestSchema = z
         endDate: z.coerce.date(),
         groupBy: z.nativeEnum(SalesByPositionGroupByEnum).default(SalesByPositionGroupByEnum.PRODUCT),
     })
+    // dateBasis / excludeClientUUID — те же, что у JSON-эндпоинтов отчётов по заказам.
+    .merge(ReportOrderFilterSchema)
     .refine(value => dateRangeCheck(value.startDate, value.endDate), {
         message: 'validation.dateRange',
         path: ['endDate', 'startDate'],

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { dateRangeCheck } from '../../helpers/date.helper';
 import { ReportPeriodTypeEnum } from '../../enum/report-period-type.enum';
+import { ReportOrderFilterSchema } from '../../schemas/report/report-order-filter.schema';
 
 const ExportSalesRevenueRequestSchema = z
     .object({
@@ -8,6 +9,8 @@ const ExportSalesRevenueRequestSchema = z
         endDate: z.coerce.date().optional(),
         periodType: z.nativeEnum(ReportPeriodTypeEnum).default(ReportPeriodTypeEnum.DAY),
     })
+    // dateBasis / excludeClientUUID — те же, что у JSON-эндпоинтов отчётов по заказам.
+    .merge(ReportOrderFilterSchema)
     .refine(
         value => {
             const { startDate, endDate } = value;

package/commands/report/get-cash-flow.query.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { dateRangeCheck, isStatementPeriodWithinLimit } from '../../helpers/date.helper';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const GetCashFlowRequestSchema = z
     .object({
@@ -28,8 +29,8 @@ const CashFlowItemRowSchema = z.object({
     // null — строка "Без статьи": платежи, которым статью ещё не проставили.
     cashFlowItemUUID: z.string().nullable(),
     cashFlowItemName: z.string().nullable(),
-    income: z.number(),
-    expense: z.number(),
+    income: MoneySchema,
+    expense: MoneySchema,
     transactionCount: z.number(),
 });
 
@@ -43,9 +44,11 @@ const GetCashFlowResponseSchema = z.object({
         byItem: CashFlowItemRowSchema.array(),
         byMonth: CashFlowMonthRowSchema.array(),
         totals: z.object({
-            income: z.number(),
-            expense: z.number(),
-            total: z.number(),
+            income: MoneySchema,
+            expense: MoneySchema,
+            // Сальдо (`income - expense`) — знаковая величина, минус здесь легален,
+            // поэтому ограничения на знак нет и быть не должно.
+            total: MoneySchema,
         }),
     }),
 });

package/commands/report/get-daily-orders-summary.query.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { dateRangeCheck, isStatementPeriodWithinLimit } from '../../helpers/date.helper';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const GetDailyOrdersSummaryRequestSchema = z
     .object({
@@ -24,7 +25,7 @@ const UnitsByMeasureSchema = z.object({
 const metricsShape = {
     ordersCreated: z.number(),
     ordersCompleted: z.number(),
-    totalSum: z.number(),
+    totalSum: MoneySchema,
     unitsByMeasure: UnitsByMeasureSchema,
 };
 

package/commands/report/get-report-for-period.query.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { dateRangeCheck } from '../../helpers/date.helper';
+import { MoneySchema } from '../../schemas/money.schema';
 
 const GetReportForPeriodRequestSchema = z
     .object({
@@ -25,17 +26,17 @@ const GetReportForPeriodResponseSchema = z.object({
     data: z.object({
         totalOrders: z.number(),
         soldUnits: z.number(),
-        totalSales: z.number(),
-        totalCost: z.number(),
+        totalSales: MoneySchema,
+        totalCost: MoneySchema,
         totalUnits: z.number(),
-        totalWriteOff: z.number(),
-        totalWriteOffCost: z.number(),
+        totalWriteOff: z.number(), // количество списанных единиц (SUM по quantity), не деньги
+        totalWriteOffCost: MoneySchema,
         totalWriteOffByOrder: z.number(),
-        totalWriteOffCostByOrder: z.number(),
-        totalVatAmount: z.number(),
-        totalDeliveryCost: z.number(),
-        middlePrice: z.number(),
-        grossProfit: z.number(),
+        totalWriteOffCostByOrder: MoneySchema,
+        totalVatAmount: MoneySchema,
+        totalDeliveryCost: MoneySchema,
+        middlePrice: MoneySchema,
+        grossProfit: MoneySchema,
         marginality: z.number(),
     }),
 });

package/commands/report/get-report-group-by-client.query.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { OrderByEnum, ReportSortByEnum } from '../../enum';
 import { dateRangeCheck } from '../../helpers/date.helper';
+import { MoneySchema } from '../../schemas/money.schema';
+import { ReportOrderFilterSchema } from '../../schemas/report/report-order-filter.schema';
 
 const GetReportGroupByClientRequestSchema = z
     .object({
@@ -21,6 +23,9 @@ const GetReportGroupByClientRequestSchema = z
         // Без значения — ограничения нет: панель по-прежнему получает все строки.
         limit: z.coerce.number().int().positive().optional().describe('Keep only the top N rows; implies sorting by gross profit desc.'),
     })
+    // dateBasis / excludeClientUUID общие с sales/summary: обе цифры живут на одном экране и должны
+    // сужаться одинаково.
+    .merge(ReportOrderFilterSchema)
     .refine(
         value => {
             const { startDate, endDate } = value;
@@ -45,16 +50,16 @@ const GetReportGroupByClientResponseSchema = z.object({
                 clientName: z.string(),
                 totalOrders: z.number(),
                 soldUnits: z.number(),
-                totalSales: z.number(),
-                totalSalesCost: z.number(),
-                totalWriteOff: z.number(),
-                totalWriteOffSales: z.number(),
-                totalVatAmount: z.number(),
-                totalDeliveryCost: z.number(),
-                totalServiceAmount: z.number(),
-                totalPayments: z.number(),
-                middlePrice: z.number(),
-                grossProfit: z.number(),
+                totalSales: MoneySchema,
+                totalSalesCost: MoneySchema,
+                totalWriteOff: z.number(), // количество списанных единиц (SUM по quantity), не деньги
+                totalWriteOffSales: MoneySchema, // деньги: SUM(write_off.quantity * order_product.price)
+                totalVatAmount: MoneySchema,
+                totalDeliveryCost: MoneySchema,
+                totalServiceAmount: MoneySchema,
+                totalPayments: MoneySchema,
+                middlePrice: MoneySchema,
+                grossProfit: MoneySchema,
                 marginality: z.number(),
             }),
         ),