@floristcloud/api-lib 1.2.180 → 1.2.182

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

@@ -1,43 +1,6 @@
-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(),
-    consignmentUUID: z.string(),
-    categoryUUID: z.string(),
-    balance: z.number(),
-    quantity: z.number(),
-    price: MoneySchema,
-    costPrice: MoneySchema,
-    multiplicity: z.number(),
-    isOpen: z.coerce.boolean(),
-
-    article: z.string().nullable(),
-    vbn: z.string().nullable(),
-    barcode: z.string().nullable(),
-    color: z.string().nullable(),
-    size: z.string().nullable(),
-    size2: z.string().nullable(),
-    size3: z.string().nullable(),
-    invoicePrice: MoneySchema.nullable(),
-    invoiceNumber: z.string().nullable(),
-    imageUUID: z.string().nullable(),
-    country: z.string().nullable(),
-    description: z.string().nullable(),
-    quality: z.string().nullable(),
-    grower: z.string().nullable(),
-    vat: z.number().nullable(),
-    multiplicityDescription: z.string().nullable(),
-    salesUnit: z.nativeEnum(SalesUnitEnum).optional().nullable(),
-    marks: z.array(z.nativeEnum(ProductMarkEnum)).optional(),
-});
-
-const UpdateProductResponseSchema = z.object({
-    message: z.string().optional(),
-    data: ProductExtendedForAdminSchema,
-});
+import type { z } from 'zod';
+import { UpdateProductRequestSchema } from '../../schemas/product/update-product-request.schema';
+import { UpdateProductResponseSchema } from '../../schemas/product/update-product-response.schema';
 
 export namespace UpdateProductContractCommand {
     export const RequestSchema = UpdateProductRequestSchema;

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

@@ -1,77 +1,6 @@
-import { z } from 'zod';
-import { OrderStatusEnum } from '../../enum/order-status.enum';
-import { ReportOrderDateBasisEnum } from '../../enum/report-order-date-basis.enum';
-import { dateRangeCheck, isStatementPeriodWithinLimit } from '../../helpers/date.helper';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const GetDailyOrdersSummaryRequestSchema = z
-    .object({
-        startDate: z.coerce.date(),
-        endDate: z.coerce.date(),
-        // Ось периода — общая с отчётами продаж, чтобы сводка и отчёт за тот же период не разошлись
-        // в семантике. Дизъюнкции «любая из дат» здесь нет намеренно, см. ReportOrderDateBasisEnum.
-        //
-        // COMPLETED_AT сужает сводку до отгруженных заказов: даты отгрузки у остальных статусов
-        // просто нет. Поэтому на этой оси ordersCompleted равен ordersCreated, а фильтр по любому
-        // статусу кроме COMPLETED даёт нули — на фронте эти два фильтра совмещать не нужно.
-        dateBasis: z.nativeEnum(ReportOrderDateBasisEnum).default(ReportOrderDateBasisEnum.CREATED_AT),
-        // Необязательное сужение по статусу. Принимается и CSV (`?status=NEW,ACCEPTED`), и повтор
-        // параметра — как excludeClientUUID в ReportOrderFilterSchema.
-        //
-        // Служебные статусы здесь НЕ отсеиваются, хотя в сводку они и так не попадают: отсев на
-        // этом слое означал бы «фильтр пуст → фильтра нет», и `?status=TEMPLATE` вернул бы весь
-        // отчёт вместо нулей. Отбрасывает их билдер — там пустой результат остаётся пустым.
-        status: z
-            .union([z.string(), z.array(z.string())])
-            .transform(value => (Array.isArray(value) ? value : value.split(',')).map(item => item.trim()).filter(Boolean))
-            .pipe(z.array(z.nativeEnum(OrderStatusEnum)))
-            .optional(),
-    })
-    .refine(value => dateRangeCheck(value.startDate, value.endDate), {
-        message: 'validation.dateRange',
-        path: ['endDate', 'startDate'],
-    })
-    .refine(value => isStatementPeriodWithinLimit(value.startDate, value.endDate), {
-        message: 'validation.reportPeriodMax',
-        path: ['endDate', 'startDate'],
-    });
-
-const UnitsByMeasureSchema = z.object({
-    PIECE: z.number(),
-    PACK: z.number(),
-    BOX: z.number(),
-});
-
-const metricsShape = {
-    ordersCreated: z.number(),
-    ordersCompleted: z.number(),
-    totalSum: MoneySchema,
-    // Часть totalSum по заказам со статусом COMPLETED. На оси COMPLETED_AT равна totalSum:
-    // там весь срез и так отгружен.
-    completedSum: MoneySchema,
-    unitsByMeasure: UnitsByMeasureSchema,
-};
-
-const DailyOrdersSummaryTotalsSchema = z.object({ ...metricsShape });
-
-const DailyOrdersSummaryByDayItemSchema = z.object({
-    date: z.string(),
-    ...metricsShape,
-});
-
-const DailyOrdersSummaryByResponsibleItemSchema = z.object({
-    responsibleUserUUID: z.string().nullable(),
-    responsibleUserName: z.string().nullable(),
-    ...metricsShape,
-});
-
-const GetDailyOrdersSummaryResponseSchema = z.object({
-    data: z.object({
-        totals: DailyOrdersSummaryTotalsSchema,
-        byDay: z.array(DailyOrdersSummaryByDayItemSchema),
-        byResponsible: z.array(DailyOrdersSummaryByResponsibleItemSchema),
-    }),
-});
+import type { z } from 'zod';
+import { GetDailyOrdersSummaryRequestSchema } from '../../schemas/report/get-daily-orders-summary-request.schema';
+import { GetDailyOrdersSummaryResponseSchema } from '../../schemas/report/get-daily-orders-summary-response.schema';
 
 export namespace GetDailyOrdersSummaryContractQuery {
     export const RequestSchema = GetDailyOrdersSummaryRequestSchema;

package/constant/error.ts

@@ -234,6 +234,34 @@ export const ERRORS = {
     BRANCH_NOT_FOUND: { code: 'B004', message: 'Branch not founded', httpCode: 404 },
     BRANCH_NOT_DELETED: { code: 'B005', message: 'Branch not deleted', httpCode: 500 },
     BRANCH_NOT_UPDATED: { code: 'B006', message: 'Branch not updated', httpCode: 500 },
+    // MEASURE_UNIT
+    MEASURE_UNIT_NOT_FOUND: { code: 'MU001', message: 'Measure unit not found', httpCode: 404 },
+    MEASURE_UNIT_NAME_EXISTS: { code: 'MU002', message: 'Measure unit name is already used', httpCode: 409 },
+    MEASURE_UNIT_SHORT_NAME_EXISTS: { code: 'MU003', message: 'Measure unit short name is already used', httpCode: 409 },
+    MEASURE_UNIT_ALIAS_CONFLICT: { code: 'MU004', message: 'Measure unit alias overlaps another unit', httpCode: 409 },
+    MEASURE_UNIT_INVALID_OKEI: { code: 'MU005', message: 'OKEI code must contain three digits', httpCode: 400 },
+    MEASURE_UNIT_DEFAULT_ARCHIVE: { code: 'MU006', message: 'Cannot archive the default measure unit', httpCode: 400 },
+    MEASURE_UNIT_ARCHIVED_DEFAULT: { code: 'MU007', message: 'Cannot make an archived measure unit default', httpCode: 400 },
+    MEASURE_UNIT_ARCHIVED: { code: 'MU008', message: 'Measure unit is archived', httpCode: 400 },
+    MEASURE_UNIT_INVALID_ORDER: {
+        code: 'MU009',
+        message: 'Measure unit order must contain all units or all active units exactly once',
+        httpCode: 400,
+    },
+    MEASURE_UNIT_FAILED: { code: 'MU010', message: 'Failed to process measure units', httpCode: 500 },
+    MEASURE_UNIT_INVALID_NAME: { code: 'MU011', message: 'Measure unit names must not be empty', httpCode: 400 },
+    MEASURE_UNIT_ALREADY_LINKED: { code: 'MU012', message: 'Measure unit is already linked to another external unit', httpCode: 409 },
+    MEASURE_UNIT_INVALID_TEXT: {
+        code: 'MU013',
+        message: 'Measure unit names or aliases exceed limits or contain control characters (name/alias: 100, short name: 32, aliases: 50)',
+        httpCode: 400,
+    },
+    MEASURE_UNIT_LIMIT_EXCEEDED: {
+        code: 'MU014',
+        message: 'Company may have at most 100 measure units, including archived units',
+        httpCode: 400,
+    },
+
     //PRODUCT
     PRODUCT_NOT_CREATED: { code: 'P001', message: 'Failed to create product', httpCode: 500 },
     PRODUCT_FETCH_FAILED: { code: 'P002', message: 'Error when retrieving a product', httpCode: 500 },
@@ -544,6 +572,13 @@ export const ERRORS = {
     ORDER_PLANNED_SHIPMENT_DATE_NOT_UPDATED: { code: 'O062', message: 'Failed to update order planned shipment date', httpCode: 500 },
     // Источник объединения удаляется, и его связь с документом ERP пропала бы молча.
     ORDER_MERGE_SOURCE_HAS_EXTERNAL_NUMBER: { code: 'O064', message: 'Source order has an external number', httpCode: 400 },
+    // FC-569: заказ отгружен до даты перехода на НДС — пересчёт его не трогает.
+    ORDER_VAT_TRANSITION_NOT_ELIGIBLE: {
+        code: 'O065',
+        message: 'The order was shipped before the VAT transition date',
+        httpCode: 409,
+    },
+    ORDER_VAT_TRANSITION_FAILED: { code: 'O066', message: 'Failed to recalculate order VAT', httpCode: 500 },
     ORDER_MERGE_BALANCE_STATUS_NOT_ALLOWED: {
         code: 'O033',
         message: 'Order status is balance affecting, merge not allowed',
@@ -1936,9 +1971,12 @@ export const ERRORS = {
     },
     TRANSFER_DOCUMENT_AMOUNT_INVALID: { code: 'TDOC009', message: 'Transfer document amount must be greater than zero', httpCode: 400 },
     TRANSFER_DOCUMENT_EXPORT_FAILED: { code: 'TDOC010', message: 'Failed to build transfer document file', httpCode: 500 },
-    TRANSFER_DOCUMENT_VAT_NOT_SUPPORTED: {
-        code: 'TDOC011',
-        message: 'Transfer documents are only issued as an act (status 2); VAT payers are not supported yet',
+    // FC-569: статус документа выводится из заказов — с НДС счёт-фактура (статус 1), без НДС акт (статус 2),
+    // и заказы обоих видов в один документ не сходятся. TDOC011 («плательщики НДС не поддерживаются»)
+    // больше не выдаётся: статус 1 выпускается.
+    TRANSFER_DOCUMENT_VAT_MIXED: {
+        code: 'TDOC015',
+        message: 'Orders with and without VAT cannot be issued in one transfer document',
         httpCode: 409,
     },
     // Реквизиты сторон проверяем до выпуска: движок считает пустое значение штатным и напечатал бы

package/constant/index.ts

@@ -16,3 +16,4 @@ export * from './client-group-actions.constant';
 export * from './standing-order-positions.constant';
 export * from './order-external-number.constant';
 export * from './discount-rules-pricing-type-list.constant';
+export * from './measure-unit-limits';

package/constant/measure-unit-limits.ts

@@ -0,0 +1 @@
+export const MEASURE_UNIT_LIMITS = { name: 100, shortName: 32, alias: 100, aliases: 50, perCompany: 100 };

package/enum/external-entity-type.enum.ts

@@ -1,4 +1,5 @@
 export enum ExternalEntityTypeEnum {
+    MEASURE_UNIT = 'MEASURE_UNIT',
     PRODUCT = 'PRODUCT',
     CATEGORY = 'CATEGORY',
     CLIENT = 'CLIENT',

package/enum/index.ts

@@ -55,6 +55,7 @@ export * from './language.enum';
 export * from './legal-identifier-field.enum';
 export * from './match-confidence.enum';
 export * from './moysklad-sync-status.enum';
+export * from './moysklad-import-item-status.enum';
 export * from './normalization-decision-action.enum';
 export * from './normalization-target.enum';
 export * from './normalization-value-state.enum';
@@ -162,3 +163,4 @@ export * from './pre-order-fulfillment-status.enum';
 
 export * from './delivery-pricing-rule-scope.enum';
 export * from './delivery-pricing-in-transit-mode.enum';
+export * from './measure-unit-match-source.enum';

package/enum/measure-unit-match-source.enum.ts

@@ -0,0 +1,6 @@
+export enum MeasureUnitMatchSourceEnum {
+    LINK = 'LINK',
+    OKEI = 'OKEI',
+    NAME = 'NAME',
+    DEFAULT = 'DEFAULT',
+}

package/enum/moysklad-import-item-status.enum.ts

@@ -0,0 +1,6 @@
+// Строка предпросмотра импорта из МойСклада: NEW — в FC ещё нет, создастся; KNOWN — уже связана ссылкой.
+// Значения в нижнем регистре — так их уже шлёт и сравнивает fc-app.
+export enum MoyskladImportItemStatusEnum {
+    NEW = 'new',
+    KNOWN = 'known',
+}

package/enum/order-updated-field.enum.ts

@@ -18,4 +18,6 @@ export enum OrderUpdatedFieldEnum {
     PAYMENT_DUE_AT = 'PAYMENT_DUE_AT',
     PLANNED_SHIPMENT_DATE = 'PLANNED_SHIPMENT_DATE',
     EXTERNAL_NUMBER = 'EXTERNAL_NUMBER',
+    // Пересчёт НДС заказа при переходе компании на НДС (FC-569): итог налога до и после.
+    VAT_AMOUNT = 'VAT_AMOUNT',
 }

package/package.json

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

package/schemas/consignment/consignment-product-multiplicity-option-update.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const ConsignmentProductMultiplicityOptionUpdateSchema = z.object({
+    title: z.string().nullable().optional(),
+    optionMultiplicity: z.number().nullable().optional(),
+    optionPrice: MoneySchema.nullable().optional(),
+    // Отсутствие поля — флаг не меняем; у создаваемой кратности берётся умолчание (скидки разрешены).
+    // Пустая ячейка в файле сюда не доезжает: разбор превращает её в отсутствие поля, а не в `false`.
+    isDiscountAllowed: z.boolean().optional(),
+});

package/schemas/consignment/consignment-product-position-update.schema.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../enum/sales-unit.enum';
+import { MoneySchema } from '../money.schema';
+import { ConsignmentProductMultiplicityOptionUpdateSchema } from './consignment-product-multiplicity-option-update.schema';
+
+export const ConsignmentProductPositionUpdateSchema = z.object({
+    measureUnitUUID: z.string().uuid().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable().optional(),
+    measureUnitText: z.string().nullable().optional(),
+    name: z.string().nullable().optional(),
+    multiplicity: z.number().nullable().optional(),
+    quantity: z.number().nullable().optional(),
+    balance: 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(),
+    article: z.string().nullable().optional(),
+    color: z.string().nullable().optional(),
+    vbn: z.string().nullable().optional(),
+    barcode: z.string().nullable().optional(),
+    size: z.string().nullable().optional(),
+    size2: z.string().nullable().optional(),
+    size3: z.string().nullable().optional(),
+    country: z.string().nullable().optional(),
+    description: z.string().nullable().optional(),
+    quality: z.string().nullable().optional(),
+    grower: z.string().nullable().optional(),
+    // `null` — слот кратности очищен, кратность надо удалить; отсутствие поля — слотом не управляем.
+    // Различие существенное: обновление по схеме импорта видит только те колонки, что она отображает,
+    // и не должно сносить кратность, которую просто не читает.
+    option1: ConsignmentProductMultiplicityOptionUpdateSchema.nullable().optional(),
+    option2: ConsignmentProductMultiplicityOptionUpdateSchema.nullable().optional(),
+});

package/schemas/consignment/execute-consignment-product-update-request.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ConsignmentProductPositionUpdateSchema } from './consignment-product-position-update.schema';
+
+export const ExecuteConsignmentProductUpdateRequestSchema = z.object({
+    updates: z.record(z.string(), ConsignmentProductPositionUpdateSchema),
+});

package/schemas/consignment/execute-consignment-product-update-response-data-errors.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+
+export const ExecuteConsignmentProductUpdateResponseDataErrorsSchema = ErrorMessageSchema.extend({
+    uuid: z.string(),
+});

package/schemas/consignment/execute-consignment-product-update-response-data.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { ExecuteConsignmentProductUpdateResponseDataErrorsSchema } from './execute-consignment-product-update-response-data-errors.schema';
+
+export const ExecuteConsignmentProductUpdateResponseDataSchema = z.object({
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    success: z.boolean(),
+    successCount: z.number(),
+    failedCount: z.number(),
+    errors: z.array(ExecuteConsignmentProductUpdateResponseDataErrorsSchema),
+});

package/schemas/consignment/execute-consignment-product-update-response.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { ExecuteConsignmentProductUpdateResponseDataSchema } from './execute-consignment-product-update-response-data.schema';
+
+export const ExecuteConsignmentProductUpdateResponseSchema = z.object({
+    data: ExecuteConsignmentProductUpdateResponseDataSchema,
+});

package/schemas/consignment/import-consignment-request-constant-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ConsignmentImportSchemaRelationEntityPropertyEnum } from '../../enum';
+
+export const ImportConsignmentRequestConstantDataSchema = z.object({
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.INVOICE_NUMBER]: z.string().nullable().optional(),
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.GROWER]: z.string().nullable().optional(),
+    [ConsignmentImportSchemaRelationEntityPropertyEnum.COUNTRY]: z.string().nullable().optional(),
+});

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { ConsignmentImportNameConventionEnum } from '../../enum';
+import { ImportConsignmentRequestConstantDataSchema } from './import-consignment-request-constant-data.schema';
+
+export const ImportConsignmentRequestSchema = z.object({
+    isAggregate: z.coerce.boolean().optional().default(false),
+    isSeparateByGrower: z.coerce.boolean().optional().default(false),
+    isCutCategoryFromName: z.coerce.boolean().optional().default(false),
+    isFindImage: z.coerce.boolean().optional().default(false),
+    isRemoveSize: z.coerce.boolean().optional().default(false),
+    tradeMargin: z.coerce.number().optional().default(0),
+    coefficient: z.coerce.number().optional().default(0),
+    nameConvention: z.nativeEnum(ConsignmentImportNameConventionEnum).optional(),
+    constantData: ImportConsignmentRequestConstantDataSchema.optional(),
+});

package/schemas/consignment/import-consignment-response-data-warnings.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { DataNotExistsSchema } from './consignment.schema';
+import { ProductErrorTypeSchema } from './consignment.schema';
+
+export const ImportConsignmentResponseDataWarningsSchema = z.object({
+    row: z.number(),
+    errors: z.array(z.union([ProductErrorTypeSchema, DataNotExistsSchema])),
+});

package/schemas/consignment/import-consignment-response-data.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ImportConsignmentResponseDataWarningsSchema } from './import-consignment-response-data-warnings.schema';
+
+export const ImportConsignmentResponseDataSchema = z.object({
+    success: z.boolean(),
+    rows: z.number(),
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    warnings: z.array(ImportConsignmentResponseDataWarningsSchema),
+});

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ImportConsignmentResponseDataSchema } from './import-consignment-response-data.schema';
+
+export const ImportConsignmentResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ImportConsignmentResponseDataSchema,
+});

package/schemas/consignment/import-packing-consignment-request.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const ImportPackingConsignmentRequestSchema = z.object({
+    isSeparateByGrower: z.coerce.boolean().optional().default(false),
+    isCutCategoryFromName: z.coerce.boolean().optional().default(false),
+    isRemoveSize: z.coerce.boolean().optional().default(false),
+});

package/schemas/consignment/import-packing-consignment-response-data-warnings.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { DataNotExistsSchema } from './consignment.schema';
+import { ProductErrorTypeSchema } from './consignment.schema';
+
+export const ImportPackingConsignmentResponseDataWarningsSchema = z.object({
+    row: z.number(),
+    productUUID: z.string().uuid().optional(),
+    errors: z.array(z.union([ProductErrorTypeSchema, DataNotExistsSchema])),
+});

package/schemas/consignment/import-packing-consignment-response-data.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ImportPackingConsignmentResponseDataWarningsSchema } from './import-packing-consignment-response-data-warnings.schema';
+
+export const ImportPackingConsignmentResponseDataSchema = z.object({
+    success: z.boolean(),
+    rows: z.number(),
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    warnings: z.array(ImportPackingConsignmentResponseDataWarningsSchema),
+});

package/schemas/consignment/import-packing-consignment-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ImportPackingConsignmentResponseDataSchema } from './import-packing-consignment-response-data.schema';
+
+export const ImportPackingConsignmentResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ImportPackingConsignmentResponseDataSchema,
+});

package/schemas/consignment/index.ts

@@ -0,0 +1,16 @@
+export * from './import-consignment-request-constant-data.schema';
+export * from './import-consignment-request.schema';
+export * from './import-consignment-response-data-warnings.schema';
+export * from './import-consignment-response-data.schema';
+export * from './import-consignment-response.schema';
+export * from './import-packing-consignment-request.schema';
+export * from './import-packing-consignment-response-data-warnings.schema';
+export * from './import-packing-consignment-response-data.schema';
+export * from './import-packing-consignment-response.schema';
+
+export * from './consignment-product-multiplicity-option-update.schema';
+export * from './consignment-product-position-update.schema';
+export * from './execute-consignment-product-update-request.schema';
+export * from './execute-consignment-product-update-response-data-errors.schema';
+export * from './execute-consignment-product-update-response-data.schema';
+export * from './execute-consignment-product-update-response.schema';

package/schemas/index.ts

@@ -129,3 +129,17 @@ export * from './write-off/write-off-archive-file.schema';
 export * from './write-off/write-off-export.schema';
 export * from './write-off/write-off-list.schema';
 export * from './write-off/write-off.schema';
+export * from './measure-unit';
+
+export * from './integration/one-c/update-one-c-settings-request.schema';
+export * from './integration/one-c/update-one-c-settings-response.schema';
+
+export * from './report/measure-unit-quantity.schema';
+
+export * from './consignment';
+
+export * from './product/group';
+
+export * from './report';
+
+export * from './integration/moysklad';

package/schemas/integration/moysklad/execute-moysklad-import-request.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { MEASURE_UNIT_LIMITS } from '../../../constant/measure-unit-limits';
+import { MoyskladMeasureUnitMappingSchema } from './moysklad-measure-unit-mapping.schema';
+import { MoyskladExecutableItemSchema } from './moysklad-executable-item.schema';
+
+export const ExecuteMoyskladImportRequestSchema = z.object({
+    measureUnitMapping: z
+        .array(MoyskladMeasureUnitMappingSchema)
+        .max(MEASURE_UNIT_LIMITS.perCompany, 'MeasureUnit.mapping.max')
+        .refine(items => new Set(items.map(item => item.externalId)).size === items.length, 'Duplicate externalId')
+        .optional(),
+    items: z.array(MoyskladExecutableItemSchema),
+    missingExternalIds: z.array(z.string()).default([]),
+    orphanedExternalIds: z.array(z.string()).default([]),
+});

package/schemas/integration/moysklad/execute-moysklad-import-response-data.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MoyskladMeasureUnitAliasAddedSchema } from './moysklad-measure-unit-alias-added.schema';
+
+export const ExecuteMoyskladImportResponseDataSchema = z.object({
+    measureUnitAliasesAdded: z.array(MoyskladMeasureUnitAliasAddedSchema),
+    created: z.number(),
+    updated: z.number(),
+    archived: z.number(),
+    orphansCleaned: z.number(),
+    consignmentUUID: z.string(),
+});

package/schemas/integration/moysklad/execute-moysklad-import-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ExecuteMoyskladImportResponseDataSchema } from './execute-moysklad-import-response-data.schema';
+
+export const ExecuteMoyskladImportResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ExecuteMoyskladImportResponseDataSchema,
+});

package/schemas/integration/moysklad/index.ts

@@ -6,3 +6,21 @@ export * from './moysklad-order-state-mapping.schema';
 export * from './moysklad-order-state-mapping.type';
 export * from './moysklad-status.schema';
 export * from './moysklad-sync-dead-info.schema';
+
+export * from './moysklad-scanned-item.schema';
+export * from './moysklad-category-match.schema';
+export * from './scan-moysklad-import-response-data-categories.schema';
+export * from './scan-moysklad-import-response-data-summary.schema';
+export * from './scan-moysklad-import-response-data.schema';
+export * from './scan-moysklad-import-response.schema';
+export * from './moysklad-executable-item.schema';
+export * from './execute-moysklad-import-request.schema';
+export * from './execute-moysklad-import-response-data.schema';
+export * from './execute-moysklad-import-response.schema';
+export * from './moysklad-measure-unit-link-mapping.schema';
+export * from './moysklad-measure-unit-create-mapping.schema';
+export * from './moysklad-measure-unit-mapping.schema';
+export * from './moysklad-scanned-measure-unit.schema';
+
+export * from './moysklad-measure-unit-alias-added.schema';
+export * from './moysklad-measure-unit-dictionary-item.schema';

package/schemas/integration/moysklad/moysklad-category-match.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const MoyskladCategoryMatchSchema = z.object({
+    fcCategoryUUID: z.string(),
+    fcCategoryName: z.string(),
+    itemsCount: z.number(),
+});

package/schemas/integration/moysklad/moysklad-executable-item.schema.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { MoyskladImportItemStatusEnum, SalesUnitEnum } from '../../../enum';
+import { MoneySchema } from '../../money.schema';
+
+export const MoyskladExecutableItemSchema = z.object({
+    externalSourceId: z.string(),
+    externalHref: z.string(),
+    name: z.string(),
+    article: z.string().nullable(),
+    barcode: z.string().nullable(),
+    size: z.string().nullable(),
+    color: z.string().nullable(),
+    country: z.string().nullable(),
+    grower: z.string().nullable(),
+    price: MoneySchema,
+    costPrice: MoneySchema,
+    balance: z.number(),
+    vat: z.number().nullable(),
+    measureUnitExternalId: z.string().nullable().optional(),
+    measureUnitUUID: z.string().uuid().optional(),
+    uomCode: z.string().nullable().optional(),
+    uomName: z.string().nullable().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable().optional(),
+    status: z.nativeEnum(MoyskladImportItemStatusEnum),
+    internalUUID: z.string().nullable(),
+    resolvedCategoryUUID: z.string().nullable(),
+    resolvedImageUUID: z.string().nullable(),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-alias-added.schema.ts

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

package/schemas/integration/moysklad/moysklad-measure-unit-create-mapping.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { CreateMeasureUnitRequestSchema } from '../../measure-unit/create-measure-unit-request.schema';
+
+export const MoyskladMeasureUnitCreateMappingSchema = CreateMeasureUnitRequestSchema.omit({ aliases: true }).extend({
+    externalId: z.string().min(1),
+    action: z.literal('CREATE'),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-dictionary-item.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { MeasureUnitShortSchema } from '../../measure-unit/measure-unit-short.schema';
+
+export const MoyskladMeasureUnitDictionaryItemSchema = MeasureUnitShortSchema.extend({
+    linkedExternalId: z.string().nullable(),
+    linkedExternalName: z.string().nullable(),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-link-mapping.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const MoyskladMeasureUnitLinkMappingSchema = z.object({
+    externalId: z.string().min(1),
+    action: z.literal('LINK'),
+    measureUnitUUID: z.string().uuid(),
+});

package/schemas/integration/moysklad/moysklad-measure-unit-mapping.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { MoyskladMeasureUnitLinkMappingSchema } from './moysklad-measure-unit-link-mapping.schema';
+import { MoyskladMeasureUnitCreateMappingSchema } from './moysklad-measure-unit-create-mapping.schema';
+
+export const MoyskladMeasureUnitMappingSchema = z.discriminatedUnion('action', [
+    MoyskladMeasureUnitLinkMappingSchema,
+    MoyskladMeasureUnitCreateMappingSchema,
+]);