@floristcloud/api-lib 1.2.180 → 1.2.181

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,
+]);

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/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(),
+});