@floristcloud/api-lib 1.2.161 → 1.2.163

package/schemas/parser/ozexport-job-stock-line-ids.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { OzexportJobStockLineIdSchema } from './ozexport-job-stock-line-id.schema';
+
+// Stock lines одного предложения — с запасом: на практике их единицы.
+const OZEXPORT_STOCK_LINES_PER_OFFER_MAX = 50;
+
+export const OzexportJobStockLineIdsSchema = z.array(OzexportJobStockLineIdSchema).max(OZEXPORT_STOCK_LINES_PER_OFFER_MAX);

package/schemas/parser/ozexport-job-stock-type.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+
+// Пустая строка — неизвестный тип плитки; это часть ключа предложения, не отсутствие поля.
+export const OzexportJobStockTypeSchema = z.string().trim().max(32);

package/schemas/parser/ozexport-refresh-offer.schema.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { OzexportJobProductCodeSchema } from './ozexport-job-product-code.schema';
+import { OzexportJobProductUrlSchema } from './ozexport-job-product-url.schema';
+import { OzexportJobSortSchema } from './ozexport-job-sort.schema';
+import { OzexportJobStockLineIdsSchema } from './ozexport-job-stock-line-ids.schema';
+import { OzexportJobStockTypeSchema } from './ozexport-job-stock-type.schema';
+
+export const OzexportRefreshOfferSchema = z.object({
+    productCode: OzexportJobProductCodeSchema,
+    // Тип плитки из ключа предложения ('' — неизвестен). Парсер возвращает его в наблюдениях этого кода эхом, как
+    // есть: NOT_FOUND и FOUND помечают ровно ключ (company, provider, productCode, stockType).
+    stockType: OzexportJobStockTypeSchema,
+    // Сохранённые stock lines — быстрый путь через availability; пусто — сразу PDP.
+    stockLineIds: OzexportJobStockLineIdsSchema,
+    // Адрес PDP (только https://www.ozexport.nl); парсер всё равно сверяет его со своим allowlist, прежде чем идти.
+    pdpUrl: OzexportJobProductUrlSchema.nullable(),
+    // Сорт предложения, как API его хранит (SupplierOffer: name, grower, color; картинки и VBN у предложения нет — null).
+    // Парсер отдаёт его в FOUND этого ключа; API для OFFERS_REFRESH сорт и шаблон предложения не меняет.
+    sort: OzexportJobSortSchema,
+});

package/schemas/parser/parse-batch-accepted-element.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const ParseBatchAcceptedElementSchema = z.object({
+    index: z.number().int().min(0),
+    sourceKey: z.string(),
+});

package/schemas/parser/parse-batch-element.schema.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+
+const PARSE_TEXT_MAX_LENGTH = 255;
+
+const PARSE_URL_MAX_LENGTH = 2048;
+
+// Ключ картинки в хранилище, который парсер кладёт при загрузке: files/parser/<имя>, только безопасные символы.
+const PARSER_IMAGE_KEY_PATTERN = /^files\/parser\/[A-Za-z0-9._-]+(\/[A-Za-z0-9._-]+)*$/;
+
+// Внешняя картинка сорта — только https и только хосты каталога ozexport (CDN картинок и прокси cloudinary).
+const EXTERNAL_IMAGE_HOST_PATTERN = /^(img\.ozexport\.nl|res\.cloudinary\.com)$/;
+
+const PARSE_VBN_MAX_LENGTH = 32;
+
+export const ParseBatchElementSchema = z.object({
+    // trim здесь только для проверки «не пусто»: String.prototype.trim режет тот же набор пробелов, что и
+    // каноническая нормализация текста источника в API (normalizeSourceText), которая и строит ключ сорта.
+    name: z.string().trim().min(1).max(PARSE_TEXT_MAX_LENGTH),
+    // Цвет — атрибут, не часть сорта: кривое значение обнуляется, элемент не выбрасывается.
+    color: z.string().max(PARSE_TEXT_MAX_LENGTH).nullable().catch(null),
+    grower: z.string().max(PARSE_TEXT_MAX_LENGTH).nullable(),
+    internalImageUrl: z
+        .string()
+        .max(PARSE_URL_MAX_LENGTH)
+        .regex(PARSER_IMAGE_KEY_PATTERN)
+        .refine(key => !key.split('/').some(segment => segment === '..' || segment === '.'), {
+            message: 'Image key must not contain dot segments',
+        }),
+    // Необязательное обогащение сорта: кривое значение превращается в null, а не выбрасывает элемент.
+    externalImageUrl: z
+        .url({ protocol: /^https$/, hostname: EXTERNAL_IMAGE_HOST_PATTERN })
+        .max(PARSE_URL_MAX_LENGTH)
+        .nullish()
+        .catch(null)
+        .transform(value => value ?? null),
+    vbn: z
+        .string()
+        .trim()
+        .min(1)
+        .max(PARSE_VBN_MAX_LENGTH)
+        .nullish()
+        .catch(null)
+        .transform(value => value ?? null),
+});

package/schemas/parser/parser-job-acknowledgement.schema.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const ParserJobAcknowledgementSchema = z.object({ isSuccess: z.boolean() });

package/schemas/parser/process-parse-batch-s2s-request.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+// Парсер шлёт батч из нескольких страниц каталога (сейчас 4 страницы): с запасом, но не безгранично.
+const PARSE_BATCH_MAX_ELEMENTS = 500;
+
+export const ProcessParseBatchS2SRequestSchema = z.object({
+    parseUUID: z.string().uuid(),
+    batchElements: z.array(z.unknown()).max(PARSE_BATCH_MAX_ELEMENTS),
+});

package/schemas/parser/process-parse-batch-s2s-response.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { ParseBatchAcceptedElementSchema } from './parse-batch-accepted-element.schema';
+
+export const ProcessParseBatchS2SResponseSchema = z.object({
+    isSuccess: z.boolean(),
+    createdCount: z.number().int(),
+    updatedCount: z.number().int(),
+    accepted: z.array(ParseBatchAcceptedElementSchema),
+});

package/schemas/parser/start-ozexport-job-base.shape.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { OzexportAccountUnitSchema } from '../integration/ozexport/ozexport-account-unit.schema';
+import { OzexportJobAttemptSchema } from './ozexport-job-attempt.schema';
+import { OzexportJobCredentialsSchema } from './ozexport-job-credentials.schema';
+
+export const StartOzexportJobBaseShape = {
+    jobId: z.uuid(),
+    attempt: OzexportJobAttemptSchema,
+    // Только в теле запроса; не логировать и не сохранять (см. OzexportJobCredentialsSchema).
+    credentials: OzexportJobCredentialsSchema,
+    // Юнит покупателя; null — основной юнит, без переключения (в первой версии всегда null).
+    unitUid: OzexportAccountUnitSchema.shape.uid.nullable(),
+    // После дедлайна обход прекращается, но complete всё равно отправляется.
+    deadlineAt: z.iso.datetime(),
+};

package/schemas/parser/start-ozexport-job-s2s-request-account-crawl.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { SupplierSyncJobKindEnum } from '../../enum/supplier-sync-job-kind.enum';
+import { StartOzexportJobBaseShape } from './start-ozexport-job-base.shape';
+
+export const StartOzexportJobS2SRequestAccountCrawlSchema = z.object({
+    ...StartOzexportJobBaseShape,
+    kind: z.literal(SupplierSyncJobKindEnum.ACCOUNT_CRAWL),
+});

package/schemas/parser/start-ozexport-job-s2s-request-offers-refresh.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { SupplierSyncJobKindEnum } from '../../enum/supplier-sync-job-kind.enum';
+import { OzexportRefreshOfferSchema } from './ozexport-refresh-offer.schema';
+import { StartOzexportJobBaseShape } from './start-ozexport-job-base.shape';
+
+const OZEXPORT_REFRESH_OFFERS_MAX = 1000;
+
+export const StartOzexportJobS2SRequestOffersRefreshSchema = z.object({
+    ...StartOzexportJobBaseShape,
+    kind: z.literal(SupplierSyncJobKindEnum.OFFERS_REFRESH),
+    offers: z.array(OzexportRefreshOfferSchema).min(1).max(OZEXPORT_REFRESH_OFFERS_MAX),
+});

package/schemas/parser/start-ozexport-job-s2s-request.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { StartOzexportJobS2SRequestAccountCrawlSchema } from './start-ozexport-job-s2s-request-account-crawl.schema';
+import { StartOzexportJobS2SRequestOffersRefreshSchema } from './start-ozexport-job-s2s-request-offers-refresh.schema';
+
+// Повтор start по (jobId, attempt) идемпотентен: таймаут API не создаёт вторую попытку и даёт ALREADY_RUNNING.
+export const StartOzexportJobS2SRequestSchema = z.discriminatedUnion('kind', [
+    StartOzexportJobS2SRequestAccountCrawlSchema,
+    StartOzexportJobS2SRequestOffersRefreshSchema,
+]);

package/schemas/parser/start-ozexport-job-s2s-response-already-running.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseAlreadyRunningSchema = z.object({
+    outcome: z.literal(OzexportJobStartOutcomeEnum.ALREADY_RUNNING),
+});

package/schemas/parser/start-ozexport-job-s2s-response-busy.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseBusySchema = z.object({ outcome: z.literal(OzexportJobStartOutcomeEnum.BUSY) });

package/schemas/parser/start-ozexport-job-s2s-response-finished.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+import { OzexportJobResultSchema } from './ozexport-job-result.schema';
+
+export const StartOzexportJobS2SResponseFinishedSchema = z.object({
+    outcome: z.literal(OzexportJobStartOutcomeEnum.FINISHED),
+    result: OzexportJobResultSchema,
+});

package/schemas/parser/start-ozexport-job-s2s-response-paused.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponsePausedSchema = z.object({
+    outcome: z.literal(OzexportJobStartOutcomeEnum.PAUSED),
+    pausedUntil: z.iso.datetime(),
+});

package/schemas/parser/start-ozexport-job-s2s-response-shutting-down.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseShuttingDownSchema = z.object({ outcome: z.literal(OzexportJobStartOutcomeEnum.SHUTTING_DOWN) });

package/schemas/parser/start-ozexport-job-s2s-response-started.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import { OzexportJobStartOutcomeEnum } from '../../enum/ozexport-job-start-outcome.enum';
+
+export const StartOzexportJobS2SResponseStartedSchema = z.object({ outcome: z.literal(OzexportJobStartOutcomeEnum.STARTED) });

package/schemas/parser/start-ozexport-job-s2s-response.schema.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { StartOzexportJobS2SResponseAlreadyRunningSchema } from './start-ozexport-job-s2s-response-already-running.schema';
+import { StartOzexportJobS2SResponseBusySchema } from './start-ozexport-job-s2s-response-busy.schema';
+import { StartOzexportJobS2SResponseFinishedSchema } from './start-ozexport-job-s2s-response-finished.schema';
+import { StartOzexportJobS2SResponsePausedSchema } from './start-ozexport-job-s2s-response-paused.schema';
+import { StartOzexportJobS2SResponseShuttingDownSchema } from './start-ozexport-job-s2s-response-shutting-down.schema';
+import { StartOzexportJobS2SResponseStartedSchema } from './start-ozexport-job-s2s-response-started.schema';
+
+// Все исходы start возвращаются с HTTP 200: HTTP-сбой означает недоступность, а не состояние задания.
+export const StartOzexportJobS2SResponseSchema = z.discriminatedUnion('outcome', [
+    StartOzexportJobS2SResponseStartedSchema,
+    StartOzexportJobS2SResponseAlreadyRunningSchema,
+    StartOzexportJobS2SResponseFinishedSchema,
+    StartOzexportJobS2SResponseBusySchema,
+    StartOzexportJobS2SResponsePausedSchema,
+    StartOzexportJobS2SResponseShuttingDownSchema,
+]);

package/schemas/positive-decimal4.schema.ts

@@ -0,0 +1,3 @@
+import { Decimal4Schema } from './decimal4.schema';
+
+export const PositiveDecimal4Schema = Decimal4Schema.refine(value => /[1-9]/.test(value), { message: 'Must be greater than zero' });

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-request.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { MatchingConfigSchema } from '../pre-order-product/matching-config.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema = z.object({
+    standingOrderUUIDs: z.uuid().array(),
+    preOrderCollectionUUIDs: z.uuid().array(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data-analyses-mappings.schema.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { PreOrderProductExtendedSchema } from '../pre-order-product/pre-order-product-extended.schema';
+import { CopyAnalysisMatchSchema } from './copy-analysis-match.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSchema = z.object({
+    standingOrderProduct: PreOrderProductExtendedSchema,
+    matches: z.array(CopyAnalysisMatchSchema),
+    remainingQuantity: z.number(),
+    /**
+     * Requested collections this standing-order line has already been converted into. Sending the
+     * line into one of them again is rejected, so the preview has to leave it out of the plan.
+     */
+    alreadyConvertedCollectionUUIDs: z.uuid().array(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data-analyses.schema.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSchema } from './analyze-create-pre-orders-from-standing-orders-response-data-analyses-mappings.schema';
+import { PreOrderWithClientSchema } from './pre-order.schema';
+import { StandingOrderConversionTargetSchema } from './standing-order-conversion-target.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesSchema = z.object({
+    standingOrder: PreOrderWithClientSchema,
+    mappings: z.record(z.string(), AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSchema),
+    warnings: z.record(z.string(), z.array(ErrorMessageSchema)),
+    targets: StandingOrderConversionTargetSchema.array(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data-error-list.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema = z.object({
+    standingOrderUUID: z.uuid(),
+    code: z.string(),
+    message: z.string(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesSchema } from './analyze-create-pre-orders-from-standing-orders-response-data-analyses.schema';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema } from './analyze-create-pre-orders-from-standing-orders-response-data-error-list.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataSchema = z.object({
+    analyses: z.array(AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesSchema),
+    errorList: z.array(AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema).optional(),
+});

package/schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseDataSchema } from './analyze-create-pre-orders-from-standing-orders-response-data.schema';
+
+export const AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema = z.object({
+    message: z.string().optional(),
+    data: AnalyzeCreatePreOrdersFromStandingOrdersResponseDataSchema,
+});

package/schemas/pre-order/copy-analysis-mapping.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { PreOrderProductExtendedSchema } from '../pre-order-product/pre-order-product-extended.schema';
+import { CopyAnalysisMatchSchema } from './copy-analysis-match.schema';
+
+export const CopyAnalysisMappingSchema = z.object({
+    sourceProduct: PreOrderProductExtendedSchema,
+    matches: z.array(CopyAnalysisMatchSchema),
+    remainingQuantity: z.number(),
+});

package/schemas/pre-order/copy-analysis-match.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { PreOrderCollectionItemForAdminSchema } from '../pre-order-collection-item/pre-order-collection-item-for-admin.schema';
+
+export const CopyAnalysisMatchSchema = z.object({
+    collectionItem: PreOrderCollectionItemForAdminSchema,
+    quantity: z.number(),
+});

package/schemas/pre-order/copy-analysis.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { CopyAnalysisMappingSchema } from './copy-analysis-mapping.schema';
+import { PreOrderWithClientSchema } from './pre-order.schema';
+
+export const CopyAnalysisSchema = z.object({
+    preOrder: PreOrderWithClientSchema,
+    mappings: z.record(z.string(), CopyAnalysisMappingSchema),
+    warnings: z.record(z.string(), z.array(ErrorMessageSchema)),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-request.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { MatchingConfigSchema } from '../pre-order-product/matching-config.schema';
+
+export const GroupCopyPreOrdersToCollectionRequestSchema = z.object({
+    preOrderUUIDList: z.array(z.uuid()),
+    targetPreOrderCollectionUUID: z.uuid(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data-created-target-pre-order.schema.ts

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

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data-created.schema.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { PreOrderCopySourceSchema } from './pre-order-copy-source.schema';
+import { GroupCopyPreOrdersToCollectionResponseDataCreatedTargetPreOrderSchema } from './group-copy-pre-orders-to-collection-response-data-created-target-pre-order.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseDataCreatedSchema = z.object({
+    sourcePreOrder: PreOrderCopySourceSchema,
+    targetPreOrder: GroupCopyPreOrdersToCollectionResponseDataCreatedTargetPreOrderSchema,
+    warnings: z.array(ErrorMessageSchema),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data-failed.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { PreOrderCopySourceSchema } from './pre-order-copy-source.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseDataFailedSchema = z.object({
+    sourcePreOrder: PreOrderCopySourceSchema,
+    error: z.array(ErrorMessageSchema),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response-data.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { GroupCopyPreOrdersToCollectionResponseDataCreatedSchema } from './group-copy-pre-orders-to-collection-response-data-created.schema';
+import { GroupCopyPreOrdersToCollectionResponseDataFailedSchema } from './group-copy-pre-orders-to-collection-response-data-failed.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseDataSchema = z.object({
+    created: z.array(GroupCopyPreOrdersToCollectionResponseDataCreatedSchema),
+    failed: z.array(GroupCopyPreOrdersToCollectionResponseDataFailedSchema),
+});

package/schemas/pre-order/group-copy-pre-orders-to-collection-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { GroupCopyPreOrdersToCollectionResponseDataSchema } from './group-copy-pre-orders-to-collection-response-data.schema';
+
+export const GroupCopyPreOrdersToCollectionResponseSchema = z.object({
+    message: z.string().optional(),
+    data: GroupCopyPreOrdersToCollectionResponseDataSchema,
+});

package/schemas/pre-order/group-create-pre-orders-from-standing-orders-request.schema.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { MatchingConfigSchema } from '../pre-order-product/matching-config.schema';
+import { StandingOrderConversionPlanEntrySchema } from './standing-order-conversion-plan-entry.schema';
+
+export const GroupCreatePreOrdersFromStandingOrdersRequestSchema = z.object({
+    standingOrderUUIDs: z.uuid().array(),
+    preOrderCollectionUUIDs: z.uuid().array(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+    /**
+     * The conversion the user confirmed in the preview. Without it the server re-runs the matching
+     * and converts whatever it finds at that moment; with it the matching is skipped and exactly
+     * these allocations are created. Carries the collection item choice and quantity only — the
+     * price always comes from the collection item.
+     */
+    plan: StandingOrderConversionPlanEntrySchema.array().optional(),
+});

package/schemas/pre-order/group-create-pre-orders-from-standing-orders-response.schema.ts

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

package/schemas/pre-order/group-delete-pre-order-request.schema.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+
+export const GroupDeletePreOrderRequestSchema = z.object({
+    uuids: z.array(z.string()).min(1),
+});

package/schemas/pre-order/group-delete-pre-order-response.schema.ts

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

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { UpdatePreOrderSchema } from './pre-order.schema';
+
+export const GroupUpdatePreOrderRequestSchema = z.object({
+    uuids: z.array(z.string()).min(1),
+    data: UpdatePreOrderSchema,
+});

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

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

package/schemas/pre-order/index.ts

@@ -1,9 +1,39 @@
-export * from './pre-order.schema';
-export * from './pre-order-summary.schema';
-export * from './pre-order-extended-for-client.schema';
-export * from './pre-order-extended-for-client-list.schema';
-export * from './get-pre-order-webshop-response.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-request.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data-analyses-mappings.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data-analyses.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data-error-list.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response-data.schema';
+export * from './analyze-create-pre-orders-from-standing-orders-response.schema';
+export * from './copy-analysis-mapping.schema';
+export * from './copy-analysis-match.schema';
+export * from './copy-analysis.schema';
 export * from './get-pre-order-list-webshop-request.schema';
 export * from './get-pre-order-list-webshop-response.schema';
-export * from './pre-order-copy.schema';
+export * from './get-pre-order-webshop-response.schema';
+export * from './group-copy-pre-orders-to-collection-request.schema';
+export * from './group-copy-pre-orders-to-collection-response-data-created-target-pre-order.schema';
+export * from './group-copy-pre-orders-to-collection-response-data-created.schema';
+export * from './group-copy-pre-orders-to-collection-response-data-failed.schema';
+export * from './group-copy-pre-orders-to-collection-response-data.schema';
+export * from './group-copy-pre-orders-to-collection-response.schema';
+export * from './group-create-pre-orders-from-standing-orders-request.schema';
+export * from './group-create-pre-orders-from-standing-orders-response.schema';
+export * from './group-delete-pre-order-request.schema';
+export * from './group-delete-pre-order-response.schema';
+export * from './group-update-pre-order-request.schema';
+export * from './group-update-pre-order-response.schema';
+export * from './pre-order-extended-for-client-list.schema';
+export * from './pre-order-extended-for-client.schema';
 export * from './pre-order-for-client.schema';
+export * from './pre-order-from-standing-order.schema';
+export * from './pre-order-summary.schema';
+export * from './pre-order.schema';
+export * from './standing-order-conversion-created.schema';
+export * from './standing-order-conversion-failed-error.schema';
+export * from './standing-order-conversion-failed.schema';
+export * from './standing-order-conversion-plan-allocation.schema';
+export * from './standing-order-conversion-plan-entry.schema';
+export * from './standing-order-conversion-plan-line.schema';
+export * from './standing-order-conversion-result.schema';
+export * from './standing-order-conversion-target-pre-order.schema';
+export * from './standing-order-conversion-target.schema';

package/schemas/pre-order/pre-order-copy-source.schema.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const PreOrderCopySourceSchema = z.object({ uuid: z.string(), preOrderNum: z.number(), clientName: z.string() });

package/schemas/pre-order/pre-order-from-standing-order.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import { PreOrderSchema } from './pre-order.schema';
+
+export const PreOrderFromStandingOrderSchema = PreOrderSchema.extend({
+    preOrderCollectionUUID: z.string(),
+});

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { PreOrderStatusEnum } from '../../enum';
+import { PreOrderStatusEnum } from '../../enum/pre-order-status.enum';
 import { ClientSchema } from '../client/client-base.schema';
 import { BranchSchema } from '../branch/branch.schema';
 import { PreOrderCollectionSchema } from '../pre-order-collection/pre-order-collection.schema';

package/schemas/pre-order/standing-order-conversion-created.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { ErrorMessageSchema } from '../error-message.schema';
+import { PreOrderFromStandingOrderSchema } from './pre-order-from-standing-order.schema';
+
+export const StandingOrderConversionCreatedSchema = z.object({
+    standingOrderUUID: z.uuid(),
+    preOrders: PreOrderFromStandingOrderSchema.array(),
+    warnings: ErrorMessageSchema.array(),
+});

package/schemas/pre-order/standing-order-conversion-failed-error.schema.ts

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

package/schemas/pre-order/standing-order-conversion-failed.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { StandingOrderConversionFailedErrorSchema } from './standing-order-conversion-failed-error.schema';
+
+export const StandingOrderConversionFailedSchema = z.object({
+    standingOrderUUID: z.uuid(),
+    error: StandingOrderConversionFailedErrorSchema,
+});

package/schemas/pre-order/standing-order-conversion-plan-allocation.schema.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+
+export const StandingOrderConversionPlanAllocationSchema = z.object({
+    preOrderCollectionItemUUID: z.uuid(),
+    quantity: z.number().int().positive(),
+});

package/schemas/pre-order/standing-order-conversion-plan-entry.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { StandingOrderConversionPlanLineSchema } from './standing-order-conversion-plan-line.schema';
+
+export const StandingOrderConversionPlanEntrySchema = z.object({
+    standingOrderUUID: z.uuid(),
+    lines: StandingOrderConversionPlanLineSchema.array(),
+});

package/schemas/pre-order/standing-order-conversion-plan-line.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { StandingOrderConversionPlanAllocationSchema } from './standing-order-conversion-plan-allocation.schema';
+
+export const StandingOrderConversionPlanLineSchema = z.object({
+    standingOrderProductUUID: z.uuid(),
+    allocations: StandingOrderConversionPlanAllocationSchema.array(),
+});

package/schemas/pre-order/standing-order-conversion-result.schema.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { StandingOrderConversionCreatedSchema } from './standing-order-conversion-created.schema';
+import { StandingOrderConversionFailedSchema } from './standing-order-conversion-failed.schema';
+
+export const StandingOrderConversionResultSchema = z.object({
+    created: StandingOrderConversionCreatedSchema.array(),
+    failed: StandingOrderConversionFailedSchema.array(),
+});

package/schemas/pre-order/standing-order-conversion-target-pre-order.schema.ts

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

package/schemas/pre-order/standing-order-conversion-target.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { StandingOrderConversionTargetPreOrderSchema } from './standing-order-conversion-target-pre-order.schema';
+
+export const StandingOrderConversionTargetSchema = z.object({
+    preOrderCollectionUUID: z.uuid(),
+    /**
+     * The open pre-order of the same client and branch the lines will be appended to; `null` means
+     * a new pre-order is created. A snapshot of the analysis moment: execution looks it up again.
+     */
+    existingPreOrder: StandingOrderConversionTargetPreOrderSchema.nullable(),
+});

package/schemas/pre-order-collection-item/create-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 CreatePreOrderCollectionItemResponseSchema = z.object({
+    message: z.string().optional(),
+    data: PreOrderCollectionItemForAdminSchema,
+});