@floristcloud/api-lib 1.2.160 → 1.2.162

package/schemas/pre-order-collection-item/supplier-add-analyze-request.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { IntegrationProviderEnum } from '../../enum/integration-provider.enum';
+import { hasUniqueSupplierAddKeys } from './has-unique-supplier-add-keys.helper';
+import { SUPPLIER_ADD_ITEMS_LIMIT } from './supplier-add-items-limit.constant';
+import { SupplierAddOfferKeySchema } from './supplier-add-offer-key.schema';
+
+export const SupplierAddAnalyzeRequestSchema = z.object({
+    provider: z.literal(IntegrationProviderEnum.OZEXPORT),
+    items: z
+        .array(SupplierAddOfferKeySchema)
+        .min(1)
+        .max(SUPPLIER_ADD_ITEMS_LIMIT)
+        .refine(hasUniqueSupplierAddKeys, { message: 'validation.supplierAdd.duplicateKeys' }),
+});

package/schemas/pre-order-collection-item/supplier-add-analyze-response-data.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { SupplierAddAnalyzeItemSchema } from './supplier-add-analyze-item.schema';
+
+export const SupplierAddAnalyzeResponseDataSchema = z.object({
+    items: z.array(SupplierAddAnalyzeItemSchema),
+});

package/schemas/pre-order-collection-item/supplier-add-analyze-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { SupplierAddAnalyzeResponseDataSchema } from './supplier-add-analyze-response-data.schema';
+
+export const SupplierAddAnalyzeResponseSchema = z.object({
+    message: z.string().optional(),
+    data: SupplierAddAnalyzeResponseDataSchema,
+});

package/schemas/pre-order-collection-item/supplier-add-execute-created-item.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const SupplierAddExecuteCreatedItemSchema = z.object({
+    productCode: z.string(),
+    stockType: z.string(),
+    itemUUID: z.string(),
+});

package/schemas/pre-order-collection-item/supplier-add-execute-item.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { SupplierAddOfferKeySchema } from './supplier-add-offer-key.schema';
+import { SupplierAddSalePriceSchema } from './supplier-add-sale-price.schema';
+
+// Кратность — Int колонки позиции (int4).
+const MULTIPLICITY_MAX = 2147483647;
+
+export const SupplierAddExecuteItemSchema = SupplierAddOfferKeySchema.extend({
+    price: SupplierAddSalePriceSchema,
+    multiplicity: z.number().int().min(1).max(MULTIPLICITY_MAX).optional(),
+    isOpen: z.boolean().optional(),
+});

package/schemas/pre-order-collection-item/supplier-add-execute-request.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { IntegrationProviderEnum } from '../../enum/integration-provider.enum';
+import { hasUniqueSupplierAddKeys } from './has-unique-supplier-add-keys.helper';
+import { SupplierAddExecuteItemSchema } from './supplier-add-execute-item.schema';
+import { SUPPLIER_ADD_ITEMS_LIMIT } from './supplier-add-items-limit.constant';
+
+export const SupplierAddExecuteRequestSchema = z.object({
+    provider: z.literal(IntegrationProviderEnum.OZEXPORT),
+    items: z
+        .array(SupplierAddExecuteItemSchema)
+        .min(1)
+        .max(SUPPLIER_ADD_ITEMS_LIMIT)
+        .refine(hasUniqueSupplierAddKeys, { message: 'validation.supplierAdd.duplicateKeys' }),
+    // true — добавить и те предложения, которые в коллекции уже есть (ALREADY_IN_COLLECTION не пропускается).
+    allowDuplicates: z.boolean().optional().default(false),
+});

package/schemas/pre-order-collection-item/supplier-add-execute-response-data.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { SupplierAddExecuteCreatedItemSchema } from './supplier-add-execute-created-item.schema';
+import { SupplierAddExecuteSkippedItemSchema } from './supplier-add-execute-skipped-item.schema';
+
+export const SupplierAddExecuteResponseDataSchema = z.object({
+    createdCount: z.number().int(),
+    items: z.array(SupplierAddExecuteCreatedItemSchema),
+    skipped: z.array(SupplierAddExecuteSkippedItemSchema),
+});

package/schemas/pre-order-collection-item/supplier-add-execute-response.schema.ts

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

package/schemas/pre-order-collection-item/supplier-add-execute-skipped-item.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { SupplierAddSkipReasonEnum } from '../../enum/supplier-add-skip-reason.enum';
+
+export const SupplierAddExecuteSkippedItemSchema = z.object({
+    productCode: z.string(),
+    stockType: z.string(),
+    reason: z.nativeEnum(SupplierAddSkipReasonEnum),
+});

package/schemas/pre-order-collection-item/supplier-add-items-limit.constant.ts

@@ -0,0 +1,2 @@
+// Не больше стольких предложений за один запрос добавления из каталога поставщика (analyze и execute).
+export const SUPPLIER_ADD_ITEMS_LIMIT = 500;

package/schemas/pre-order-collection-item/supplier-add-offer-key.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+const PRODUCT_CODE_MAX_LENGTH = 128;
+
+const STOCK_TYPE_MAX_LENGTH = 64;
+
+export const SupplierAddOfferKeySchema = z.object({
+    productCode: z.string().trim().min(1).max(PRODUCT_CODE_MAX_LENGTH),
+    stockType: z.string().trim().max(STOCK_TYPE_MAX_LENGTH),
+});

package/schemas/pre-order-collection-item/supplier-add-sale-price.schema.ts

@@ -0,0 +1,9 @@
+import { NonNegativeMoneySchema } from '../non-negative-money.schema';
+
+// Decimal(12,2) колонки price позиции коллекции: не больше 10 цифр целой части.
+const SALE_PRICE_INTEGER_DIGITS_MAX = 10;
+
+export const SupplierAddSalePriceSchema = NonNegativeMoneySchema.refine(
+    value => (value.split('.')[0] ?? '').replace(/^0+(?=\d)/, '').length <= SALE_PRICE_INTEGER_DIGITS_MAX,
+    { message: 'validation.money.tooLarge' },
+);

package/schemas/pre-order-collection-item/supplier-sync-analyze-item.schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { SupplierSyncChangeEnum } from '../../enum/supplier-sync-change.enum';
+import { SupplierSyncCurrentSchema } from './supplier-sync-current.schema';
+import { SupplierSyncProposedSchema } from './supplier-sync-proposed.schema';
+
+export const SupplierSyncAnalyzeItemSchema = z.object({
+    itemUUID: z.string(),
+    name: z.string(),
+    current: SupplierSyncCurrentSchema,
+    proposed: SupplierSyncProposedSchema.nullable(),
+    change: z.nativeEnum(SupplierSyncChangeEnum),
+    isStale: z.boolean(),
+    isSelectable: z.boolean(),
+    version: z.string(),
+});

package/schemas/pre-order-collection-item/supplier-sync-analyze-request.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { SUPPLIER_SYNC_ITEMS_LIMIT } from './supplier-sync-items-limit.constant';
+
+export const SupplierSyncAnalyzeRequestSchema = z.object({
+    itemUUIDs: z.array(z.string().uuid()).min(1).max(SUPPLIER_SYNC_ITEMS_LIMIT).optional(),
+});

package/schemas/pre-order-collection-item/supplier-sync-analyze-response-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { SupplierSyncAnalyzeItemSchema } from './supplier-sync-analyze-item.schema';
+
+export const SupplierSyncAnalyzeResponseDataSchema = z.object({
+    items: z.array(SupplierSyncAnalyzeItemSchema),
+    lastSyncAt: z.coerce.date().nullable(),
+    hasMore: z.boolean(),
+});

package/schemas/pre-order-collection-item/supplier-sync-analyze-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { SupplierSyncAnalyzeResponseDataSchema } from './supplier-sync-analyze-response-data.schema';
+
+export const SupplierSyncAnalyzeResponseSchema = z.object({
+    message: z.string().optional(),
+    data: SupplierSyncAnalyzeResponseDataSchema,
+});

package/schemas/pre-order-collection-item/supplier-sync-current.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { Decimal4Schema } from '../decimal4.schema';
+
+export const SupplierSyncCurrentSchema = z.object({
+    offerCode: z.string(),
+    stockType: z.string(),
+    invoicePrice: Decimal4Schema.nullable(),
+    currency: z.string().nullable(),
+    observedAt: z.coerce.date().nullable(),
+    departureDate: z.iso.date().nullable(),
+    multiplicity: z.number().int(),
+});

package/schemas/pre-order-collection-item/supplier-sync-execute-item.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+// Версия — hex SHA-256 (64 символа); запас на смену формата.
+const VERSION_MAX_LENGTH = 128;
+
+export const SupplierSyncExecuteItemSchema = z.object({
+    itemUUID: z.string().uuid(),
+    version: z.string().min(1).max(VERSION_MAX_LENGTH),
+});

package/schemas/pre-order-collection-item/supplier-sync-execute-request.schema.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { SupplierSyncExecuteItemSchema } from './supplier-sync-execute-item.schema';
+import { SUPPLIER_SYNC_ITEMS_LIMIT } from './supplier-sync-items-limit.constant';
+
+const hasUniqueItemUUIDs = (
+    items: {
+        itemUUID: string;
+    }[],
+): boolean => new Set(items.map(item => item.itemUUID)).size === items.length;
+
+export const SupplierSyncExecuteRequestSchema = z.object({
+    items: z
+        .array(SupplierSyncExecuteItemSchema)
+        .min(1)
+        .max(SUPPLIER_SYNC_ITEMS_LIMIT)
+        .refine(hasUniqueItemUUIDs, { message: 'validation.supplierSync.duplicateItems' }),
+    // true — записать и кратность поставщика (incrementalOrderQuantity); по умолчанию кратность позиции не меняется.
+    applyMultiplicity: z.boolean().optional().default(false),
+});

package/schemas/pre-order-collection-item/supplier-sync-execute-response-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { SupplierSyncExecuteSkippedItemSchema } from './supplier-sync-execute-skipped-item.schema';
+
+export const SupplierSyncExecuteResponseDataSchema = z.object({
+    updatedCount: z.number().int(),
+    missingMarkedCount: z.number().int(),
+    skipped: z.array(SupplierSyncExecuteSkippedItemSchema),
+});

package/schemas/pre-order-collection-item/supplier-sync-execute-response.schema.ts

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

package/schemas/pre-order-collection-item/supplier-sync-execute-skipped-item.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { SupplierSyncSkipReasonEnum } from '../../enum/supplier-sync-skip-reason.enum';
+
+export const SupplierSyncExecuteSkippedItemSchema = z.object({
+    itemUUID: z.string(),
+    reason: z.nativeEnum(SupplierSyncSkipReasonEnum),
+});

package/schemas/pre-order-collection-item/supplier-sync-items-limit.constant.ts

@@ -0,0 +1,2 @@
+// Не больше стольких позиций за один запрос синхронизации коллекции с поставщиком (analyze и execute).
+export const SUPPLIER_SYNC_ITEMS_LIMIT = 2000;

package/schemas/pre-order-collection-item/supplier-sync-proposed.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SupplierOfferStatusEnum } from '../../enum/supplier-offer-status.enum';
+import { Decimal4Schema } from '../decimal4.schema';
+
+export const SupplierSyncProposedSchema = z.object({
+    offerCode: z.string(),
+    stockType: z.string(),
+    invoicePrice: Decimal4Schema.nullable(),
+    currency: z.string(),
+    observedAt: z.coerce.date(),
+    departureDate: z.iso.date().nullable(),
+    status: z.nativeEnum(SupplierOfferStatusEnum),
+    multiplicity: z.number().int(),
+});

package/schemas/pre-order-collection-item/supplier-sync-stale-after-hours.constant.ts

@@ -0,0 +1,2 @@
+// Предложение, наблюдавшееся у поставщика раньше стольких часов назад, в предпросмотре синхронизации помечается isStale.
+export const SUPPLIER_SYNC_STALE_AFTER_HOURS = 36;

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { UpdatePreOrderCollectionItemSchema } from './update-pre-order-collection-item.schema';
+
+export const UpdatePreOrderCollectionItemRequestSchema = UpdatePreOrderCollectionItemSchema.extend({
+    // Переданный вместе с balance expectedBalance защищает резерв предзаказа от перезаписи устаревшим остатком:
+    // несовпадение отклоняет запись с HTTP 409 (PRE_ORDER_LOCK_CONFLICT).
+    expectedBalance: z.coerce.number().nullable().optional(),
+});

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

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

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

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { SalesUnitEnum } from '../../enum/sales-unit.enum';
+import { MoneySchema } from '../money.schema';
+
+export const UpdatePreOrderCollectionItemSchema = z
+    .object({
+        productUUID: z.string().nullable(),
+        categoryUUID: z.string(),
+        isOpen: z.boolean(),
+        // preOrderCollectionUUID нет: перенос позиции в другую коллекцию — только через group-actions/move (он
+        // переносит и предзаказы); правка поля напрямую оставляла бы предзаказы в старой коллекции.
+        name: z.string(),
+        multiplicity: z.coerce.number(),
+        quantity: z.coerce.number().nullable(),
+        balance: z.coerce.number().nullable(),
+        imageUUID: z.string().nullable(),
+        price: MoneySchema,
+        advancedPrice: z.string().nullable(),
+        grower: z.string().nullable(),
+        size: z.string().nullable(),
+        isSizeCustomizable: z.boolean(),
+        size2: z.string().nullable(),
+        size3: z.string().nullable(),
+        color: z.string().nullable(),
+        isColorCustomizable: z.boolean(),
+        country: z.string().nullable(),
+        vat: z.coerce.number().nullable(),
+        description: z.string().nullable(),
+        salesUnit: z.nativeEnum(SalesUnitEnum),
+        article: z.string().nullable(),
+        group: z.string().nullable(),
+        multiplicityDescription: z.string().nullable(),
+    })
+    .partial();

package/schemas/pre-order-product/active-stepper-positions-response.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { PreOrderProductStepperPositionSchema } from './pre-order-product-stepper-position.schema';
+
+export const ActiveStepperPositionsResponseSchema = z.object({
+    list: PreOrderProductStepperPositionSchema.array(),
+});

package/schemas/pre-order-product/create-pre-order-product-webshop-request.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const CreatePreOrderProductWebshopRequestSchema = z.object({
+    preOrderCollectionItemUUID: z.string().nullable(),
+    preOrderUUID: z.string(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
+    // Целое положительное: ноль и минус уменьшали бы остаток позиции коллекции.
+    quantity: z.number().int().positive(),
+    comment: z.string().nullable(),
+    isReplaceable: z.boolean(),
+    stopPrice: MoneySchema.nullable(),
+    highAttention: z.boolean(),
+});

package/schemas/pre-order-product/create-pre-order-product-webshop-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderProductForClientSchema } from './pre-order-product-for-client.schema';
+
+export const CreatePreOrderProductWebshopResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderProductForClientSchema,
+});

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+import { MatchingConfigSchema } from './matching-config.schema';
+import { PreOrderProductQuantityRequestSchema } from './pre-order-product-quantity-request.schema';
+import { PreOrderProductSchema } from './pre-order-product-base.schema';
+
+export const CreatePreOrderProductSchema = PreOrderProductSchema.omit({ uuid: true, preOrderUUID: true }).extend({
+    quantity: PreOrderProductQuantityRequestSchema,
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
+    categoryUUID: z.string().nullable().optional(),
+    name: z.string().nullable().optional(),
+    grower: z.string().nullable().optional(),
+    size: z.string().nullable().optional(),
+    price: MoneySchema.nullable().optional(),
+    color: z.string().nullable().optional(),
+    parentPreOrderProductUUID: z.string().nullable().optional(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+});

package/schemas/pre-order-product/delete-many-pre-order-product-by-pre-order-collection-item-response-data.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const DeleteManyPreOrderProductByPreOrderCollectionItemResponseDataSchema = z.object({
+    success: z.boolean(),
+    // Сколько строк снято этим запросом.
+    deletedCount: z.number().int(),
+    // Сколько строк оставлено: их предзаказ уже сконвертирован в заказ (COMPLETED), строка — часть заказа.
+    skippedCompletedCount: z.number().int(),
+});

package/schemas/pre-order-product/delete-many-pre-order-product-by-pre-order-collection-item-response.schema.ts

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

package/schemas/pre-order-product/get-pre-order-product-extended-list-webshop-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderProductExtendedForClientListSchema } from './pre-order-product-extended-for-client-list.schema';
+
+export const GetPreOrderProductExtendedListWebshopResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderProductExtendedForClientListSchema,
+});

package/schemas/pre-order-product/index.ts

@@ -0,0 +1,22 @@
+export * from './active-stepper-positions-response.schema';
+export * from './create-pre-order-product-webshop-request.schema';
+export * from './create-pre-order-product-webshop-response.schema';
+export * from './create-pre-order-product.schema';
+export * from './delete-many-pre-order-product-by-pre-order-collection-item-response-data.schema';
+export * from './delete-many-pre-order-product-by-pre-order-collection-item-response.schema';
+export * from './get-pre-order-product-extended-list-webshop-response.schema';
+export * from './matching-config.schema';
+export * from './pre-order-product-extended-for-client-list.schema';
+export * from './pre-order-product-extended-for-client.schema';
+export * from './pre-order-product-extended-list.schema';
+export * from './pre-order-product-extended.schema';
+export * from './pre-order-product-for-client.schema';
+export * from './pre-order-product-list.schema';
+export * from './pre-order-product-quantity-request.schema';
+export * from './pre-order-product-stepper-position.schema';
+export * from './pre-order-product.schema';
+export * from './set-pre-order-product-quantity-webshop-request.schema';
+export * from './set-pre-order-product-quantity-webshop-response.schema';
+export * from './update-pre-order-product-webshop-request.schema';
+export * from './update-pre-order-product-webshop-response.schema';
+export * from './update-pre-order-product.schema';

package/schemas/pre-order-product/matching-config.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const MatchingConfigSchema = z.object({
+    matchByName: z.coerce.boolean(),
+    matchByCategory: z.coerce.boolean(),
+    matchByColor: z.coerce.boolean(),
+    matchBySize: z.coerce.boolean(),
+    matchByGrower: z.coerce.boolean(),
+    usePreOrderMultiplicity: z.coerce.boolean().optional(),
+});

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+import { MatchingConfigSchema } from './matching-config.schema';
+
+export const PreOrderProductSchema = z.object({
+    uuid: z.string(),
+    preOrderCollectionItemUUID: z.string().nullable(),
+    preOrderUUID: z.string(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
+    quantity: z.number(),
+    comment: z.string().nullable(),
+    tag: z.string().nullable(),
+    isPurchased: z.boolean(),
+    isReplaceable: z.boolean(),
+    stopPrice: MoneySchema.nullable(),
+    highAttention: z.boolean(),
+    categoryUUID: z.string().nullable(),
+    name: z.string().nullable(),
+    grower: z.string().nullable(),
+    size: z.string().nullable(),
+    price: MoneySchema.nullable(),
+    color: z.string().nullable(),
+    parentPreOrderProductUUID: z.string().nullable(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+});

package/schemas/pre-order-product/pre-order-product-extended-for-client-list.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderProductExtendedForClientSchema } from './pre-order-product-extended-for-client.schema';
+
+export const PreOrderProductExtendedForClientListSchema = z.object({
+    list: z.array(PreOrderProductExtendedForClientSchema),
+    total: z.number(),
+});

package/schemas/pre-order-product/pre-order-product-extended-for-client.schema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemMultiplicityOptionSchema } from '../pre-order-collection-item/pre-order-collection-item-multiplicity-option.schema';
+import { PreOrderProductForClientSchema } from './pre-order-product-for-client.schema';
+import { PreOrderCollectionItemForClientSchema } from '../pre-order-collection-item/pre-order-collection-item-for-client.schema';
+import { CategoryNameSchema } from '../category/category-name.schema';
+
+export const PreOrderProductExtendedForClientSchema = PreOrderProductForClientSchema.extend({
+    preOrderCollectionItem: PreOrderCollectionItemForClientSchema.optional(),
+    // Своя категория позиции без коллекции — фронты читают только название.
+    category: CategoryNameSchema.nullable(),
+    deliveryDate: z.coerce.date().nullable(),
+    multiplicityOption: PreOrderCollectionItemMultiplicityOptionSchema.nullable().optional(),
+});

package/schemas/pre-order-product/pre-order-product-extended-list.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderProductExtendedSchema } from './pre-order-product-extended.schema';
+
+export const preOrderProductExtendedListSchema = z.object({
+    list: PreOrderProductExtendedSchema.array(),
+    total: z.number(),
+});

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

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { CategorySchema } from '../category/category.schema';
+import { PreOrderCollectionItemExtendedSchema } from '../pre-order-collection-item/pre-order-collection-item-extended.schema';
+import { PreOrderCollectionItemMultiplicityOptionSchema } from '../pre-order-collection-item/pre-order-collection-item-multiplicity-option.schema';
+import { PreOrderProductSchema } from './pre-order-product-base.schema';
+
+export const PreOrderProductExtendedSchema = PreOrderProductSchema.extend({
+    preOrderCollectionItem: PreOrderCollectionItemExtendedSchema,
+    category: CategorySchema.nullable(),
+    deliveryDate: z.coerce.date().nullable(),
+    multiplicityOption: PreOrderCollectionItemMultiplicityOptionSchema.nullable().optional(),
+});

package/schemas/pre-order-product/pre-order-product-for-client.schema.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+
+export const PreOrderProductForClientSchema = z.object({
+    uuid: z.string(),
+    preOrderCollectionItemUUID: z.string().nullable(),
+    preOrderUUID: z.string(),
+    multiplicityOptionUUID: z.uuid().nullable().optional(),
+    quantity: z.number(),
+    comment: z.string().nullable(),
+    tag: z.string().nullable(),
+    isReplaceable: z.boolean(),
+    stopPrice: MoneySchema.nullable(),
+    highAttention: z.boolean(),
+    categoryUUID: z.string().nullable(),
+    name: z.string().nullable(),
+    grower: z.string().nullable(),
+    size: z.string().nullable(),
+    price: MoneySchema.nullable(),
+    color: z.string().nullable(),
+    parentPreOrderProductUUID: z.string().nullable(),
+});

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderProductSchema } from './pre-order-product-base.schema';
+
+export const PreOrderProductListSchema = z.object({
+    list: PreOrderProductSchema.array(),
+    total: z.number(),
+});

package/schemas/pre-order-product/pre-order-product-quantity-request.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const PreOrderProductQuantityRequestSchema = z.number().int().min(0);

package/schemas/pre-order-product/pre-order-product-stepper-position.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export const PreOrderProductStepperPositionSchema = z.object({
+    uuid: z.string(),
+    preOrderUUID: z.string(),
+    preOrderCollectionUUID: z.string().nullable(),
+    preOrderCollectionItemUUID: z.string().nullable(),
+    multiplicityOptionUUID: z.string().nullable().optional(),
+    multiplicityOptionTitle: z.string().nullable().optional(),
+    quantity: z.number(),
+    balance: z.number().nullable(),
+});