@floristcloud/api-lib 1.2.180 → 1.2.182

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { MoyskladImportItemStatusEnum, SalesUnitEnum } from '../../../enum';
+import { MoneySchema } from '../../money.schema';
+
+export const MoyskladScannedItemSchema = z.object({
+    externalSourceId: z.string(),
+    externalHref: z.string(),
+    originalName: z.string(),
+    normalizedName: 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(),
+    categoryName: z.string().nullable(),
+    vat: z.number().nullable(),
+    measureUnitExternalId: z.string().nullable(),
+    measureUnitUUID: z.string().uuid(),
+    uomCode: z.string().nullable().optional(),
+    uomName: z.string().nullable().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
+    status: z.nativeEnum(MoyskladImportItemStatusEnum),
+    internalUUID: z.string().nullable(),
+    resolvedCategoryUUID: z.string().nullable(),
+    resolvedCategoryName: z.string().nullable(),
+    resolvedImageUUID: z.string().nullable(),
+});

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MeasureUnitMatchSourceEnum } from '../../../enum/measure-unit-match-source.enum';
+
+export const MoyskladScannedMeasureUnitSchema = z.object({
+    externalId: z.string(),
+    externalName: z.string(),
+    okeiCode: z.string().nullable(),
+    itemCount: z.number(),
+    measureUnitUUID: z.string(),
+    matchedBy: z.nativeEnum(MeasureUnitMatchSourceEnum),
+});

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

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { MoyskladCategoryMatchSchema } from './moysklad-category-match.schema';
+
+export const ScanMoyskladImportResponseDataCategoriesSchema = z.object({
+    matched: z.array(MoyskladCategoryMatchSchema),
+});

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const ScanMoyskladImportResponseDataSummarySchema = z.object({
+    withCategory: z.number(),
+    withoutCategory: z.number(),
+    withColor: z.number(),
+    withCountry: z.number(),
+    withGrower: z.number(),
+    withSize: z.number(),
+    withImage: z.number(),
+});

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

@@ -0,0 +1,22 @@
+import { MoyskladMeasureUnitDictionaryItemSchema } from './moysklad-measure-unit-dictionary-item.schema';
+import { z } from 'zod';
+import { MoyskladScannedMeasureUnitSchema } from './moysklad-scanned-measure-unit.schema';
+import { MoyskladScannedItemSchema } from './moysklad-scanned-item.schema';
+import { ScanMoyskladImportResponseDataCategoriesSchema } from './scan-moysklad-import-response-data-categories.schema';
+import { ScanMoyskladImportResponseDataSummarySchema } from './scan-moysklad-import-response-data-summary.schema';
+
+export const ScanMoyskladImportResponseDataSchema = z.object({
+    measureUnitDictionary: z.array(MoyskladMeasureUnitDictionaryItemSchema).optional(),
+    measureUnits: z.array(MoyskladScannedMeasureUnitSchema),
+    rawProductCount: z.number(),
+    expandedItemCount: z.number(),
+    knownItems: z.number(),
+    newItems: z.number(),
+    missingItemsCount: z.number(),
+    missingExternalIds: z.array(z.string()),
+    orphanedItemsCount: z.number(),
+    orphanedExternalIds: z.array(z.string()),
+    categories: ScanMoyskladImportResponseDataCategoriesSchema,
+    summary: ScanMoyskladImportResponseDataSummarySchema,
+    items: z.array(MoyskladScannedItemSchema),
+});

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

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

package/schemas/integration/one-c/index.ts

@@ -11,3 +11,5 @@ export * from './one-c-stock-conflict-preview.schema';
 export * from './one-c-stock-conflict-resolution.schema';
 export * from './resolve-one-c-stock-conflict-request.schema';
 export * from './resolve-one-c-stock-conflict-response.schema';
+export * from './update-one-c-settings-request.schema';
+export * from './update-one-c-settings-response.schema';

package/schemas/integration/one-c/one-c-status.schema.ts

@@ -3,6 +3,7 @@ import { IntegrationStatusEnum } from '../../../enum/integration-status.enum';
 
 export const OneCStatusSchema = z.object({
     isConnected: z.boolean(),
+    isOrderMeasureUnitFromProduct: z.boolean(),
     status: z.nativeEnum(IntegrationStatusEnum).nullable(),
     username: z.string().nullable(),
     lastCheckauthAt: z.string().datetime().nullable(),

package/schemas/integration/one-c/update-one-c-settings-request.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const UpdateOneCSettingsRequestSchema = z.object({ isOrderMeasureUnitFromProduct: z.boolean() });

package/schemas/integration/one-c/update-one-c-settings-response.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { UpdateOneCSettingsRequestSchema } from './update-one-c-settings-request.schema';
+
+export const UpdateOneCSettingsResponseSchema = z.object({ data: UpdateOneCSettingsRequestSchema });

package/schemas/measure-unit/create-measure-unit-request.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { MEASURE_UNIT_LIMITS } from '../../constant/measure-unit-limits';
+import { MeasureUnitTextSchema } from './measure-unit-text.schema';
+
+export const CreateMeasureUnitRequestSchema = z.object({
+    name: MeasureUnitTextSchema.max(MEASURE_UNIT_LIMITS.name, 'MeasureUnit.name.max').trim().min(1),
+    shortName: MeasureUnitTextSchema.max(MEASURE_UNIT_LIMITS.shortName, 'MeasureUnit.shortName.max').trim().min(1),
+    okeiCode: z
+        .string()
+        .regex(/^\d{3}$/)
+        .nullable()
+        .optional(),
+    aliases: z
+        .array(MeasureUnitTextSchema.max(MEASURE_UNIT_LIMITS.alias, 'MeasureUnit.alias.max').trim().min(1))
+        .max(MEASURE_UNIT_LIMITS.aliases, 'MeasureUnit.aliases.max')
+        .optional(),
+});

package/schemas/measure-unit/get-measure-unit-list-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const GetMeasureUnitListRequestSchema = z.object({
+    includeArchived: z.preprocess(value => value === 'true' || value === true, z.boolean()).default(false),
+});

package/schemas/measure-unit/index.ts

@@ -0,0 +1,9 @@
+export * from './measure-unit-short.schema';
+export * from './measure-unit.schema';
+export * from './create-measure-unit-request.schema';
+export * from './update-measure-unit-request.schema';
+export * from './reorder-measure-units-request.schema';
+export * from './get-measure-unit-list-request.schema';
+export * from './measure-unit-response.schema';
+export * from './measure-unit-list-response.schema';
+export * from './measure-unit-text.schema';

package/schemas/measure-unit/measure-unit-list-response.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { MeasureUnitSchema } from './measure-unit.schema';
+
+export const MeasureUnitListResponseSchema = z.object({ data: z.array(MeasureUnitSchema) });

package/schemas/measure-unit/measure-unit-response.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { MeasureUnitSchema } from './measure-unit.schema';
+
+export const MeasureUnitResponseSchema = z.object({ data: MeasureUnitSchema });

package/schemas/measure-unit/measure-unit-short.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const MeasureUnitShortSchema = z.object({
+    uuid: z.string(),
+    name: z.string(),
+    shortName: z.string(),
+    okeiCode: z.string().nullable(),
+});

package/schemas/measure-unit/measure-unit-text.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+
+export const MeasureUnitTextSchema = z
+    .string()
+    .refine(
+        value => !Array.from(value).some(char => char.charCodeAt(0) <= 31 || char.charCodeAt(0) === 127),
+        'MeasureUnit.text.controlCharacters',
+    );

package/schemas/measure-unit/measure-unit.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../enum/sales-unit.enum';
+import { MeasureUnitShortSchema } from './measure-unit-short.schema';
+
+export const MeasureUnitSchema = MeasureUnitShortSchema.extend({
+    companyUUID: z.string(),
+    aliases: z.array(z.string()),
+    position: z.number().int(),
+    isArchived: z.boolean(),
+    isDefault: z.boolean(),
+    systemKey: z.nativeEnum(SalesUnitEnum).nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});

package/schemas/measure-unit/reorder-measure-units-request.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { MEASURE_UNIT_LIMITS } from '../../constant/measure-unit-limits';
+
+export const ReorderMeasureUnitsRequestSchema = z.object({
+    uuidList: z
+        .array(z.string().uuid())
+        .min(1)
+        .max(MEASURE_UNIT_LIMITS.perCompany, 'MeasureUnit.uuidList.max')
+        .refine(uuids => new Set(uuids).size === uuids.length, 'Duplicate UUID'),
+});

package/schemas/measure-unit/update-measure-unit-request.schema.ts

@@ -0,0 +1,3 @@
+import { CreateMeasureUnitRequestSchema } from './create-measure-unit-request.schema';
+
+export const UpdateMeasureUnitRequestSchema = CreateMeasureUnitRequestSchema.partial();

package/schemas/order/index.ts

@@ -16,3 +16,13 @@ export * from './update-cart-response.schema';
 export * from './delivery-pricing.schema';
 export * from './get-order-delivery-pricing-request.schema';
 export * from './get-order-delivery-pricing-response.schema';
+
+export * from './order-vat-transition-request.schema';
+export * from './order-vat-transition-execute-request.schema';
+export * from './order-vat-transition-analyze-item.schema';
+export * from './order-vat-transition-analyze-summary.schema';
+export * from './order-vat-transition-analyze-result.schema';
+export * from './order-vat-transition-analyze-response.schema';
+export * from './order-vat-transition-execute-failure.schema';
+export * from './order-vat-transition-execute-result.schema';
+export * from './order-vat-transition-execute-response.schema';

package/schemas/order/order-vat-transition-analyze-item.schema.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { OrderStatusEnum, OrderTypeEnum } from '../../enum';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { MoneySchema } from '../money.schema';
+
+export const OrderVatTransitionAnalyzeItemSchema = z.object({
+    orderUUID: z.string(),
+    orderNumber: z.number(),
+    status: z.nativeEnum(OrderStatusEnum),
+    type: z.nativeEnum(OrderTypeEnum),
+    // null — заказ ещё не отгружен.
+    completedAt: z.coerce.date().nullable(),
+    totalCost: MoneySchema,
+    currentVatAmount: MoneySchema,
+    newVatAmount: MoneySchema,
+    // Строки товаров и услуг, у которых меняется ставка или сумма налога; доставка не входит.
+    changedLineCount: z.number().int(),
+    isDeliveryChanged: z.boolean(),
+    // Снимок счёта на оплату пересчёт не трогает — счёт нужно выставить заново.
+    isInPaymentInvoice: z.boolean(),
+    isSkipped: z.boolean(),
+    skipReason: ErrorMessageSchema.optional(),
+});

package/schemas/order/order-vat-transition-analyze-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { OrderVatTransitionAnalyzeResultSchema } from './order-vat-transition-analyze-result.schema';
+
+export const OrderVatTransitionAnalyzeResponseSchema = z.object({
+    message: z.string().optional(),
+    data: OrderVatTransitionAnalyzeResultSchema,
+});

package/schemas/order/order-vat-transition-analyze-result.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { OrderVatTransitionAnalyzeItemSchema } from './order-vat-transition-analyze-item.schema';
+import { OrderVatTransitionAnalyzeSummarySchema } from './order-vat-transition-analyze-summary.schema';
+
+export const OrderVatTransitionAnalyzeResultSchema = z.object({
+    // Граница в UTC: полночь `fromDate` в поясе компании. Заказы с completedAt раньше неё не трогаются.
+    fromUtc: z.coerce.date(),
+    summary: OrderVatTransitionAnalyzeSummarySchema,
+    // Только заказы, которые пересчёт меняет или пропускает; уже пересчитанные не выводятся.
+    items: z.array(OrderVatTransitionAnalyzeItemSchema),
+});

package/schemas/order/order-vat-transition-analyze-summary.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const OrderVatTransitionAnalyzeSummarySchema = z.object({
+    orderCount: z.number().int(),
+    changedOrderCount: z.number().int(),
+    skippedOrderCount: z.number().int(),
+    paymentInvoiceOrderCount: z.number().int(),
+    vatAmountDelta: MoneySchema,
+    // Товары с нулевой ставкой: применение сбросит её в пусто — «по ставке компании», иначе остатки
+    // продавались бы без налога и после перехода.
+    zeroVatProductCount: z.number().int(),
+});

package/schemas/order/order-vat-transition-execute-failure.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+
+export const OrderVatTransitionExecuteFailureSchema = z.object({
+    orderUUID: z.string(),
+    orderNumber: z.number(),
+    error: ErrorMessageSchema,
+});

package/schemas/order/order-vat-transition-execute-request.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { OrderVatTransitionRequestSchema } from './order-vat-transition-request.schema';
+
+/**
+ * Набор заказов сервер собирает тем же правилом, что и предпросмотр, поэтому размер запроса не
+ * зависит от числа заказов. Снять заказ из пересчёта — `excludeOrderUUIDList`.
+ */
+export const OrderVatTransitionExecuteRequestSchema = OrderVatTransitionRequestSchema.extend({
+    excludeOrderUUIDList: z.array(z.uuid()).optional(),
+});

package/schemas/order/order-vat-transition-execute-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { OrderVatTransitionExecuteResultSchema } from './order-vat-transition-execute-result.schema';
+
+export const OrderVatTransitionExecuteResponseSchema = z.object({
+    message: z.string().optional(),
+    data: OrderVatTransitionExecuteResultSchema,
+});

package/schemas/order/order-vat-transition-execute-result.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { OrderVatTransitionExecuteFailureSchema } from './order-vat-transition-execute-failure.schema';
+
+/**
+ * Пересчёт идемпотентен: повторный запуск не трогает уже пересчитанные заказы (`unchangedCount`)
+ * и догоняет оставшиеся — например, после обрыва соединения на большом наборе.
+ */
+export const OrderVatTransitionExecuteResultSchema = z.object({
+    changedCount: z.number().int(),
+    unchangedCount: z.number().int(),
+    failedCount: z.number().int(),
+    failures: z.array(OrderVatTransitionExecuteFailureSchema),
+    resetProductCount: z.number().int(),
+});

package/schemas/order/order-vat-transition-request.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { CalendarDaySchema } from '../calendar-day.schema';
+
+/**
+ * Перевод компании на НДС с даты: заказы, отгруженные с `fromDate` (полночь в поясе компании)
+ * или ещё не отгруженные, пересчитываются по ставке `vat`. Цены и суммы не меняются — налог
+ * выделяется из суммы, поэтому балансы клиентов не затрагиваются.
+ */
+export const OrderVatTransitionRequestSchema = z.object({
+    fromDate: CalendarDaySchema,
+    vat: z.number().int().min(1).max(100),
+});

package/schemas/pre-order/import-standing-order-response-data.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { StandingOrderImportRowErrorSchema } from './standing-order-import-row-error.schema';
+
+export const ImportStandingOrderResponseDataSchema = z.object({
+    success: z.boolean(),
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    errors: z.array(StandingOrderImportRowErrorSchema),
+    warnings: z.array(StandingOrderImportRowErrorSchema),
+});

package/schemas/pre-order/import-standing-order-response.schema.ts

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

package/schemas/pre-order/index.ts

@@ -80,3 +80,7 @@ export * from './get-pre-order-by-collection-for-client-response.schema';
 export * from './revert-pre-order-conversion-order.schema';
 export * from './revert-pre-order-conversion-result.schema';
 export * from './revert-pre-order-conversion-response.schema';
+
+export * from './standing-order-import-row-error.schema';
+export * from './import-standing-order-response-data.schema';
+export * from './import-standing-order-response.schema';

package/schemas/pre-order/standing-order-import-row-error.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const StandingOrderImportRowErrorSchema = z.object({
+    row: z.number(),
+    column: z.string(),
+    message: z.string(),
+    code: z.string(),
+    i18nKey: z.string().optional(),
+    i18nParams: z.record(z.string(), z.union([z.string(), z.number(), z.null()])).optional(),
+});

package/schemas/pre-order-collection-item/create-pre-order-collection-item.schema.ts

@@ -24,7 +24,8 @@ export const CreatePreOrderCollectionItemSchema = z.object({
     vat: z.coerce.number().nullable().optional(),
     description: z.string().nullable().optional(),
     article: z.string().nullable().optional(),
-    salesUnit: z.nativeEnum(SalesUnitEnum).optional(),
+    measureUnitUUID: z.string().uuid().optional(),
+    salesUnit: z.nativeEnum(SalesUnitEnum).nullable().optional(),
     group: z.string().nullable().optional(),
     multiplicityDescription: z.string().nullable().optional(),
 });

package/schemas/pre-order-collection-item/import-pre-order-collection-item-request.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const ImportPreOrderCollectionItemRequestSchema = z.object({});

package/schemas/pre-order-collection-item/import-pre-order-collection-item-response-data.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemImportRowErrorSchema } from './pre-order-collection-item-import-row-error.schema';
+import { PreOrderCollectionItemImportGlobalErrorSchema } from './pre-order-collection-item-import-global-error.schema';
+import { PreOrderCollectionItemImportCreatedRowSchema } from './pre-order-collection-item-import-created-row.schema';
+
+export const ImportPreOrderCollectionItemResponseDataSchema = z.object({
+    rows: z.number(),
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
+    created: z.array(PreOrderCollectionItemImportCreatedRowSchema),
+    errors: z.array(PreOrderCollectionItemImportRowErrorSchema),
+    warnings: z.array(PreOrderCollectionItemImportRowErrorSchema),
+    globalErrors: z.array(PreOrderCollectionItemImportGlobalErrorSchema).optional(),
+});

package/schemas/pre-order-collection-item/import-pre-order-collection-item-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { ImportPreOrderCollectionItemResponseDataSchema } from './import-pre-order-collection-item-response-data.schema';
+
+export const ImportPreOrderCollectionItemResponseSchema = z.object({
+    message: z.string().optional(),
+    data: ImportPreOrderCollectionItemResponseDataSchema,
+});

package/schemas/pre-order-collection-item/index.ts

@@ -69,3 +69,15 @@ export * from './supplier-sync-stale-after-hours.constant';
 export * from './update-pre-order-collection-item-request.schema';
 export * from './update-pre-order-collection-item-response.schema';
 export * from './update-pre-order-collection-item.schema';
+
+export * from './import-pre-order-collection-item-request.schema';
+export * from './pre-order-collection-item-import-issue-params.schema';
+export * from './pre-order-collection-item-import-issue.schema';
+export * from './pre-order-collection-item-import-row-error.schema';
+export * from './pre-order-collection-item-import-global-error.schema';
+export * from './pre-order-collection-item-import-created-row.schema';
+export * from './import-pre-order-collection-item-response-data.schema';
+export * from './import-pre-order-collection-item-response.schema';
+export * from './update-group-pre-order-collection-item-request.schema';
+export * from './update-group-pre-order-collection-item-response-data.schema';
+export * from './update-group-pre-order-collection-item-response.schema';

package/schemas/pre-order-collection-item/pre-order-collection-item-base.schema.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { SalesUnitEnum } from '../../enum';
 import { MoneySchema } from '../money.schema';
+import { MeasureUnitShortSchema } from '../measure-unit/measure-unit-short.schema';
 
 export const PreOrderCollectionItemSchema = z.object({
     uuid: z.string(),
@@ -25,6 +26,8 @@ export const PreOrderCollectionItemSchema = z.object({
     country: z.string().nullable(),
     vat: z.number().nullable(),
     description: z.string().nullable(),
+    measureUnitUUID: z.string(),
+    measureUnit: MeasureUnitShortSchema,
     salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
     article: z.string().nullable(),
     group: z.string().nullable(),

package/schemas/pre-order-collection-item/pre-order-collection-item-for-client.schema.ts

@@ -4,6 +4,7 @@ import { SalesUnitEnum } from '../../enum';
 import { PreOrderCollectionItemMultiplicityOptionSchema } from './pre-order-collection-item-multiplicity-option.schema';
 import { PreOrderCollectionItemCategorySchema } from './pre-order-collection-item-category.schema';
 import { PreOrderCollectionItemImageSchema } from './pre-order-collection-item-image.schema';
+import { MeasureUnitShortSchema } from '../measure-unit/measure-unit-short.schema';
 
 // Позиция коллекции в предзаказе покупателя — без привязки к товару склада и служебных полей.
 export const PreOrderCollectionItemForClientSchema = z.object({
@@ -24,6 +25,8 @@ export const PreOrderCollectionItemForClientSchema = z.object({
     vat: z.number().nullable(),
     description: z.string().nullable(),
     article: z.string().nullable(),
+    measureUnitUUID: z.string(),
+    measureUnit: MeasureUnitShortSchema,
     salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
     multiplicityDescription: z.string().nullable(),
     image: PreOrderCollectionItemImageSchema.nullable(),

package/schemas/pre-order-collection-item/pre-order-collection-item-import-created-row.schema.ts

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

package/schemas/pre-order-collection-item/pre-order-collection-item-import-global-error.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemImportIssueSchema } from './pre-order-collection-item-import-issue.schema';
+
+export const PreOrderCollectionItemImportGlobalErrorSchema = z.object({
+    errors: z.array(PreOrderCollectionItemImportIssueSchema),
+});

package/schemas/pre-order-collection-item/pre-order-collection-item-import-issue-params.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const PreOrderCollectionItemImportIssueParamsSchema = z.record(
+    z.string(),
+    z.union([z.string(), z.number(), z.null(), z.array(z.string())]),
+);

package/schemas/pre-order-collection-item/pre-order-collection-item-import-issue.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemImportEntityPropertyEnum } from '../../enum';
+import { PreOrderCollectionItemImportErrorsEnum } from '../../enum';
+import { PreOrderCollectionItemImportIssueParamsSchema } from './pre-order-collection-item-import-issue-params.schema';
+
+export const PreOrderCollectionItemImportIssueSchema = z.object({
+    path: z.nativeEnum(PreOrderCollectionItemImportEntityPropertyEnum).optional(),
+    type: z.nativeEnum(PreOrderCollectionItemImportErrorsEnum),
+    params: PreOrderCollectionItemImportIssueParamsSchema.optional(),
+});

package/schemas/pre-order-collection-item/pre-order-collection-item-import-row-error.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemImportIssueSchema } from './pre-order-collection-item-import-issue.schema';
+
+export const PreOrderCollectionItemImportRowErrorSchema = z.object({
+    row: z.number(),
+    errors: z.array(PreOrderCollectionItemImportIssueSchema),
+});

package/schemas/pre-order-collection-item/pre-order-collection-item-position-update.schema.ts

@@ -22,6 +22,8 @@ export const PreOrderCollectionItemPositionUpdateSchema = z.object({
     description: z.string().nullable().optional(),
     article: z.string().nullable().optional(),
     salesUnit: z.string().nullable().optional(),
+    measureUnitText: z.string().nullable().optional(),
+    measureUnitUUID: z.string().uuid().optional(),
     group: z.string().nullable().optional(),
     multiplicityDescription: z.string().nullable().optional(),
     option1: PreOrderCollectionItemOptionUpdateSchema.optional(),

package/schemas/pre-order-collection-item/pre-order-collection-item-update-batch-response-data.schema.ts

@@ -2,6 +2,8 @@ import { z } from 'zod';
 import { PreOrderCollectionItemUpdateBatchResponseDataErrorsSchema } from './pre-order-collection-item-update-batch-response-data-errors.schema';
 
 export const PreOrderCollectionItemUpdateBatchResponseDataSchema = z.object({
+    unrecognizedMeasureUnitCount: z.number(),
+    unrecognizedMeasureUnitExamples: z.array(z.string()),
     success: z.boolean(),
     successCount: z.number(),
     failedCount: z.number(),

package/schemas/pre-order-collection-item/update-group-pre-order-collection-item-request.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { UpdatePreOrderCollectionItemSchema } from './update-pre-order-collection-item.schema';
+
+export const UpdateGroupPreOrderCollectionItemRequestSchema = z.object({
+    preOrderCollectionItemUUIDs: z.array(z.string()),
+    data: UpdatePreOrderCollectionItemSchema,
+});

package/schemas/pre-order-collection-item/update-group-pre-order-collection-item-response-data.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const UpdateGroupPreOrderCollectionItemResponseDataSchema = z.object({
+    success: z.boolean(),
+});

package/schemas/pre-order-collection-item/update-group-pre-order-collection-item-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { UpdateGroupPreOrderCollectionItemResponseDataSchema } from './update-group-pre-order-collection-item-response-data.schema';
+
+export const UpdateGroupPreOrderCollectionItemResponseSchema = z.object({
+    message: z.string().optional(),
+    data: UpdateGroupPreOrderCollectionItemResponseDataSchema,
+});

package/schemas/pre-order-collection-item/update-pre-order-collection-item.schema.ts

@@ -26,7 +26,8 @@ export const UpdatePreOrderCollectionItemSchema = z
         country: z.string().nullable(),
         vat: z.coerce.number().nullable(),
         description: z.string().nullable(),
-        salesUnit: z.nativeEnum(SalesUnitEnum),
+        measureUnitUUID: z.string().uuid().optional(),
+        salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
         article: z.string().nullable(),
         group: z.string().nullable(),
         multiplicityDescription: z.string().nullable(),