@floristcloud/api-lib 1.2.162 → 1.2.163

package/build/commands/pre-order/group/group-create-pre-orders-from-standing-orders.command.js

@@ -1,36 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupCreatePreOrdersFromStandingOrdersContractCommand = void 0;
-const zod_1 = require("zod");
-const schemas_1 = require("../../../schemas");
-const GroupCreatePreOrdersFromStandingOrdersRequestSchema = zod_1.z.object({
-    standingOrderUUIDs: zod_1.z.uuid().array(),
-    preOrderCollectionUUIDs: zod_1.z.uuid().array(),
-    matchingConfig: schemas_1.MatchingConfigSchema.optional().nullable(),
-});
-const GroupCreatePreOrdersFromStandingOrdersResponseSchema = zod_1.z.object({
-    message: zod_1.z.string().optional(),
-    data: zod_1.z.object({
-        created: zod_1.z
-            .object({
-            standingOrderUUID: zod_1.z.uuid(),
-            preOrders: schemas_1.PreOrderSchema.array(),
-            warnings: zod_1.z.array(schemas_1.ErrorMessageSchema),
-        })
-            .array(),
-        failed: zod_1.z
-            .object({
-            standingOrderUUID: zod_1.z.uuid(),
-            error: zod_1.z.object({
-                code: zod_1.z.string(),
-                message: zod_1.z.string(),
-            }),
-        })
-            .array(),
-    }),
-});
+const group_create_pre_orders_from_standing_orders_request_schema_1 = require("../../../schemas/pre-order/group-create-pre-orders-from-standing-orders-request.schema");
+const group_create_pre_orders_from_standing_orders_response_schema_1 = require("../../../schemas/pre-order/group-create-pre-orders-from-standing-orders-response.schema");
 var GroupCreatePreOrdersFromStandingOrdersContractCommand;
 (function (GroupCreatePreOrdersFromStandingOrdersContractCommand) {
-    GroupCreatePreOrdersFromStandingOrdersContractCommand.RequestSchema = GroupCreatePreOrdersFromStandingOrdersRequestSchema;
-    GroupCreatePreOrdersFromStandingOrdersContractCommand.ResponseSchema = GroupCreatePreOrdersFromStandingOrdersResponseSchema;
+    GroupCreatePreOrdersFromStandingOrdersContractCommand.RequestSchema = group_create_pre_orders_from_standing_orders_request_schema_1.GroupCreatePreOrdersFromStandingOrdersRequestSchema;
+    GroupCreatePreOrdersFromStandingOrdersContractCommand.ResponseSchema = group_create_pre_orders_from_standing_orders_response_schema_1.GroupCreatePreOrdersFromStandingOrdersResponseSchema;
 })(GroupCreatePreOrdersFromStandingOrdersContractCommand || (exports.GroupCreatePreOrdersFromStandingOrdersContractCommand = GroupCreatePreOrdersFromStandingOrdersContractCommand = {}));

package/build/constant/error-i18n-key.js

@@ -71,6 +71,17 @@ exports.ErrorI18nKey = {
     soProductNotCreated: 'preOrderFromStandingOrder.productNotCreated',
     soCriticalError: 'preOrderFromStandingOrder.criticalError',
     soNoPreOrdersCreated: 'preOrderFromStandingOrder.noPreOrdersCreated',
+    soItemSkippedInsufficientBalance: 'preOrderFromStandingOrder.itemSkippedInsufficientBalance',
+    soPlanItemPartiallyAllocated: 'preOrderFromStandingOrder.planItemPartiallyAllocated',
+    soLineAlreadyConverted: 'preOrderFromStandingOrder.lineAlreadyConverted',
+    // Standing-order → pre-order conversion plan validation
+    soPlanMismatch: 'standingOrderPlan.mismatch',
+    soPlanDuplicateStandingOrder: 'standingOrderPlan.duplicateStandingOrder',
+    soPlanDuplicateLine: 'standingOrderPlan.duplicateLine',
+    soPlanDuplicateItem: 'standingOrderPlan.duplicateItem',
+    soPlanLineNotInStandingOrder: 'standingOrderPlan.lineNotInStandingOrder',
+    soPlanItemNotAvailable: 'standingOrderPlan.itemNotAvailable',
+    soPlanQuantityExceedsLine: 'standingOrderPlan.quantityExceedsLine',
     // Pre-order → standing-order conversion warnings
     preOrderToSoSourceEmpty: 'preOrderToStandingOrder.sourceEmpty',
     preOrderToSoItemSkipped: 'preOrderToStandingOrder.itemSkipped',

package/build/constant/error.js

@@ -994,6 +994,47 @@ exports.ERRORS = {
         message: 'No pre-orders were created for this standing order: no matching items found in the selected collections',
         httpCode: 400,
     },
+    PRE_ORDER_SO_ITEM_SKIPPED_INSUFFICIENT_BALANCE: {
+        code: 'PO055',
+        message: 'Standing-order item was skipped: the collection item balance is no longer sufficient',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_ITEM_PARTIALLY_ALLOCATED: {
+        code: 'PO056',
+        message: 'Only part of the standing-order item quantity was added to the pre-order',
+        httpCode: 400,
+    },
+    // PRE ORDER — standing-order → pre-order conversion plan validation and repeat guard
+    PRE_ORDER_SO_PLAN_MISMATCH: {
+        code: 'PO049',
+        message: 'Conversion plan must cover exactly the requested standing orders',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_DUPLICATE_ENTRY: {
+        code: 'PO050',
+        message: 'Conversion plan contains duplicate entries',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_LINE_NOT_IN_STANDING_ORDER: {
+        code: 'PO051',
+        message: 'Planned line does not belong to its standing order',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_ITEM_NOT_AVAILABLE: {
+        code: 'PO052',
+        message: 'Planned collection item does not belong to the selected collections',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_QUANTITY_EXCEEDS_LINE: {
+        code: 'PO053',
+        message: 'Planned quantity exceeds the standing-order line quantity',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_LINE_ALREADY_CONVERTED: {
+        code: 'PO054',
+        message: 'Standing-order line has already been converted into this collection',
+        httpCode: 409,
+    },
     // PRE ORDER — pre-order → standing-order conversion
     PRE_ORDER_TO_STANDING_ORDER_FAILED: {
         code: 'PO044',

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

@@ -8,4 +8,9 @@ exports.AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSche
     standingOrderProduct: pre_order_product_extended_schema_1.PreOrderProductExtendedSchema,
     matches: zod_1.z.array(copy_analysis_match_schema_1.CopyAnalysisMatchSchema),
     remainingQuantity: zod_1.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: zod_1.z.uuid().array(),
 });

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

@@ -5,8 +5,10 @@ const zod_1 = require("zod");
 const error_message_schema_1 = require("../error-message.schema");
 const analyze_create_pre_orders_from_standing_orders_response_data_analyses_mappings_schema_1 = require("./analyze-create-pre-orders-from-standing-orders-response-data-analyses-mappings.schema");
 const pre_order_schema_1 = require("./pre-order.schema");
+const standing_order_conversion_target_schema_1 = require("./standing-order-conversion-target.schema");
 exports.AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesSchema = zod_1.z.object({
     standingOrder: pre_order_schema_1.PreOrderWithClientSchema,
     mappings: zod_1.z.record(zod_1.z.string(), analyze_create_pre_orders_from_standing_orders_response_data_analyses_mappings_schema_1.AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMappingsSchema),
     warnings: zod_1.z.record(zod_1.z.string(), zod_1.z.array(error_message_schema_1.ErrorMessageSchema)),
+    targets: standing_order_conversion_target_schema_1.StandingOrderConversionTargetSchema.array(),
 });

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema = void 0;
 const zod_1 = require("zod");
 exports.AnalyzeCreatePreOrdersFromStandingOrdersResponseDataErrorListSchema = zod_1.z.object({
+    standingOrderUUID: zod_1.z.uuid(),
     code: zod_1.z.string(),
     message: zod_1.z.string(),
 });

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCreatePreOrdersFromStandingOrdersRequestSchema = void 0;
+const zod_1 = require("zod");
+const matching_config_schema_1 = require("../pre-order-product/matching-config.schema");
+const standing_order_conversion_plan_entry_schema_1 = require("./standing-order-conversion-plan-entry.schema");
+exports.GroupCreatePreOrdersFromStandingOrdersRequestSchema = zod_1.z.object({
+    standingOrderUUIDs: zod_1.z.uuid().array(),
+    preOrderCollectionUUIDs: zod_1.z.uuid().array(),
+    matchingConfig: matching_config_schema_1.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: standing_order_conversion_plan_entry_schema_1.StandingOrderConversionPlanEntrySchema.array().optional(),
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCreatePreOrdersFromStandingOrdersResponseSchema = void 0;
+const zod_1 = require("zod");
+const standing_order_conversion_result_schema_1 = require("./standing-order-conversion-result.schema");
+exports.GroupCreatePreOrdersFromStandingOrdersResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: standing_order_conversion_result_schema_1.StandingOrderConversionResultSchema,
+});

package/build/schemas/pre-order/index.js

@@ -32,6 +32,8 @@ __exportStar(require("./group-copy-pre-orders-to-collection-response-data-create
 __exportStar(require("./group-copy-pre-orders-to-collection-response-data-failed.schema"), exports);
 __exportStar(require("./group-copy-pre-orders-to-collection-response-data.schema"), exports);
 __exportStar(require("./group-copy-pre-orders-to-collection-response.schema"), exports);
+__exportStar(require("./group-create-pre-orders-from-standing-orders-request.schema"), exports);
+__exportStar(require("./group-create-pre-orders-from-standing-orders-response.schema"), exports);
 __exportStar(require("./group-delete-pre-order-request.schema"), exports);
 __exportStar(require("./group-delete-pre-order-response.schema"), exports);
 __exportStar(require("./group-update-pre-order-request.schema"), exports);
@@ -39,5 +41,15 @@ __exportStar(require("./group-update-pre-order-response.schema"), exports);
 __exportStar(require("./pre-order-extended-for-client-list.schema"), exports);
 __exportStar(require("./pre-order-extended-for-client.schema"), exports);
 __exportStar(require("./pre-order-for-client.schema"), exports);
+__exportStar(require("./pre-order-from-standing-order.schema"), exports);
 __exportStar(require("./pre-order-summary.schema"), exports);
 __exportStar(require("./pre-order.schema"), exports);
+__exportStar(require("./standing-order-conversion-created.schema"), exports);
+__exportStar(require("./standing-order-conversion-failed-error.schema"), exports);
+__exportStar(require("./standing-order-conversion-failed.schema"), exports);
+__exportStar(require("./standing-order-conversion-plan-allocation.schema"), exports);
+__exportStar(require("./standing-order-conversion-plan-entry.schema"), exports);
+__exportStar(require("./standing-order-conversion-plan-line.schema"), exports);
+__exportStar(require("./standing-order-conversion-result.schema"), exports);
+__exportStar(require("./standing-order-conversion-target-pre-order.schema"), exports);
+__exportStar(require("./standing-order-conversion-target.schema"), exports);

package/build/schemas/pre-order/pre-order-from-standing-order.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderFromStandingOrderSchema = void 0;
+const zod_1 = require("zod");
+const pre_order_schema_1 = require("./pre-order.schema");
+exports.PreOrderFromStandingOrderSchema = pre_order_schema_1.PreOrderSchema.extend({
+    preOrderCollectionUUID: zod_1.z.string(),
+});

package/build/schemas/pre-order/standing-order-conversion-created.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionCreatedSchema = void 0;
+const zod_1 = require("zod");
+const error_message_schema_1 = require("../error-message.schema");
+const pre_order_from_standing_order_schema_1 = require("./pre-order-from-standing-order.schema");
+exports.StandingOrderConversionCreatedSchema = zod_1.z.object({
+    standingOrderUUID: zod_1.z.uuid(),
+    preOrders: pre_order_from_standing_order_schema_1.PreOrderFromStandingOrderSchema.array(),
+    warnings: error_message_schema_1.ErrorMessageSchema.array(),
+});

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionFailedErrorSchema = void 0;
+const zod_1 = require("zod");
+const error_message_schema_1 = require("../error-message.schema");
+exports.StandingOrderConversionFailedErrorSchema = error_message_schema_1.ErrorMessageSchema.extend({
+    code: zod_1.z.string(),
+});

package/build/schemas/pre-order/standing-order-conversion-failed.schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionFailedSchema = void 0;
+const zod_1 = require("zod");
+const standing_order_conversion_failed_error_schema_1 = require("./standing-order-conversion-failed-error.schema");
+exports.StandingOrderConversionFailedSchema = zod_1.z.object({
+    standingOrderUUID: zod_1.z.uuid(),
+    error: standing_order_conversion_failed_error_schema_1.StandingOrderConversionFailedErrorSchema,
+});

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionPlanAllocationSchema = void 0;
+const zod_1 = require("zod");
+exports.StandingOrderConversionPlanAllocationSchema = zod_1.z.object({
+    preOrderCollectionItemUUID: zod_1.z.uuid(),
+    quantity: zod_1.z.number().int().positive(),
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionPlanEntrySchema = void 0;
+const zod_1 = require("zod");
+const standing_order_conversion_plan_line_schema_1 = require("./standing-order-conversion-plan-line.schema");
+exports.StandingOrderConversionPlanEntrySchema = zod_1.z.object({
+    standingOrderUUID: zod_1.z.uuid(),
+    lines: standing_order_conversion_plan_line_schema_1.StandingOrderConversionPlanLineSchema.array(),
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionPlanLineSchema = void 0;
+const zod_1 = require("zod");
+const standing_order_conversion_plan_allocation_schema_1 = require("./standing-order-conversion-plan-allocation.schema");
+exports.StandingOrderConversionPlanLineSchema = zod_1.z.object({
+    standingOrderProductUUID: zod_1.z.uuid(),
+    allocations: standing_order_conversion_plan_allocation_schema_1.StandingOrderConversionPlanAllocationSchema.array(),
+});

package/build/schemas/pre-order/standing-order-conversion-result.schema.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionResultSchema = void 0;
+const zod_1 = require("zod");
+const standing_order_conversion_created_schema_1 = require("./standing-order-conversion-created.schema");
+const standing_order_conversion_failed_schema_1 = require("./standing-order-conversion-failed.schema");
+exports.StandingOrderConversionResultSchema = zod_1.z.object({
+    created: standing_order_conversion_created_schema_1.StandingOrderConversionCreatedSchema.array(),
+    failed: standing_order_conversion_failed_schema_1.StandingOrderConversionFailedSchema.array(),
+});

package/build/schemas/pre-order/standing-order-conversion-target-pre-order.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionTargetPreOrderSchema = void 0;
+const zod_1 = require("zod");
+exports.StandingOrderConversionTargetPreOrderSchema = zod_1.z.object({
+    uuid: zod_1.z.uuid(),
+    preOrderNum: zod_1.z.number(),
+});

package/build/schemas/pre-order/standing-order-conversion-target.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandingOrderConversionTargetSchema = void 0;
+const zod_1 = require("zod");
+const standing_order_conversion_target_pre_order_schema_1 = require("./standing-order-conversion-target-pre-order.schema");
+exports.StandingOrderConversionTargetSchema = zod_1.z.object({
+    preOrderCollectionUUID: zod_1.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: standing_order_conversion_target_pre_order_schema_1.StandingOrderConversionTargetPreOrderSchema.nullable(),
+});

package/commands/pre-order/group/analyze-create-pre-orders-from-standing-orders.command.ts

@@ -1,10 +1,11 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import { AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema } from '../../../schemas/pre-order/analyze-create-pre-orders-from-standing-orders-request.schema';
 import { AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema } from '../../../schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response.schema';
 
 export namespace AnalyzeCreatePreOrdersFromStandingOrdersContractCommand {
     export const RequestSchema = AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
+
     export const ResponseSchema = AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/pre-order/group/group-create-pre-orders-from-standing-orders.command.ts

@@ -1,33 +1,6 @@
-import { z } from 'zod';
-import { ErrorMessageSchema, MatchingConfigSchema, PreOrderSchema } from '../../../schemas';
-
-const GroupCreatePreOrdersFromStandingOrdersRequestSchema = z.object({
-    standingOrderUUIDs: z.uuid().array(),
-    preOrderCollectionUUIDs: z.uuid().array(),
-    matchingConfig: MatchingConfigSchema.optional().nullable(),
-});
-
-const GroupCreatePreOrdersFromStandingOrdersResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        created: z
-            .object({
-                standingOrderUUID: z.uuid(),
-                preOrders: PreOrderSchema.array(),
-                warnings: z.array(ErrorMessageSchema),
-            })
-            .array(),
-        failed: z
-            .object({
-                standingOrderUUID: z.uuid(),
-                error: z.object({
-                    code: z.string(),
-                    message: z.string(),
-                }),
-            })
-            .array(),
-    }),
-});
+import type { z } from 'zod';
+import { GroupCreatePreOrdersFromStandingOrdersRequestSchema } from '../../../schemas/pre-order/group-create-pre-orders-from-standing-orders-request.schema';
+import { GroupCreatePreOrdersFromStandingOrdersResponseSchema } from '../../../schemas/pre-order/group-create-pre-orders-from-standing-orders-response.schema';
 
 export namespace GroupCreatePreOrdersFromStandingOrdersContractCommand {
     export const RequestSchema = GroupCreatePreOrdersFromStandingOrdersRequestSchema;

package/constant/error-i18n-key.ts

@@ -74,6 +74,18 @@ export const ErrorI18nKey = {
     soProductNotCreated: 'preOrderFromStandingOrder.productNotCreated',
     soCriticalError: 'preOrderFromStandingOrder.criticalError',
     soNoPreOrdersCreated: 'preOrderFromStandingOrder.noPreOrdersCreated',
+    soItemSkippedInsufficientBalance: 'preOrderFromStandingOrder.itemSkippedInsufficientBalance',
+    soPlanItemPartiallyAllocated: 'preOrderFromStandingOrder.planItemPartiallyAllocated',
+    soLineAlreadyConverted: 'preOrderFromStandingOrder.lineAlreadyConverted',
+
+    // Standing-order → pre-order conversion plan validation
+    soPlanMismatch: 'standingOrderPlan.mismatch',
+    soPlanDuplicateStandingOrder: 'standingOrderPlan.duplicateStandingOrder',
+    soPlanDuplicateLine: 'standingOrderPlan.duplicateLine',
+    soPlanDuplicateItem: 'standingOrderPlan.duplicateItem',
+    soPlanLineNotInStandingOrder: 'standingOrderPlan.lineNotInStandingOrder',
+    soPlanItemNotAvailable: 'standingOrderPlan.itemNotAvailable',
+    soPlanQuantityExceedsLine: 'standingOrderPlan.quantityExceedsLine',
 
     // Pre-order → standing-order conversion warnings
     preOrderToSoSourceEmpty: 'preOrderToStandingOrder.sourceEmpty',

package/constant/error.ts

@@ -1030,6 +1030,47 @@ export const ERRORS = {
         message: 'No pre-orders were created for this standing order: no matching items found in the selected collections',
         httpCode: 400,
     },
+    PRE_ORDER_SO_ITEM_SKIPPED_INSUFFICIENT_BALANCE: {
+        code: 'PO055',
+        message: 'Standing-order item was skipped: the collection item balance is no longer sufficient',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_ITEM_PARTIALLY_ALLOCATED: {
+        code: 'PO056',
+        message: 'Only part of the standing-order item quantity was added to the pre-order',
+        httpCode: 400,
+    },
+    // PRE ORDER — standing-order → pre-order conversion plan validation and repeat guard
+    PRE_ORDER_SO_PLAN_MISMATCH: {
+        code: 'PO049',
+        message: 'Conversion plan must cover exactly the requested standing orders',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_DUPLICATE_ENTRY: {
+        code: 'PO050',
+        message: 'Conversion plan contains duplicate entries',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_LINE_NOT_IN_STANDING_ORDER: {
+        code: 'PO051',
+        message: 'Planned line does not belong to its standing order',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_ITEM_NOT_AVAILABLE: {
+        code: 'PO052',
+        message: 'Planned collection item does not belong to the selected collections',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_QUANTITY_EXCEEDS_LINE: {
+        code: 'PO053',
+        message: 'Planned quantity exceeds the standing-order line quantity',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_LINE_ALREADY_CONVERTED: {
+        code: 'PO054',
+        message: 'Standing-order line has already been converted into this collection',
+        httpCode: 409,
+    },
     // PRE ORDER — pre-order → standing-order conversion
     PRE_ORDER_TO_STANDING_ORDER_FAILED: {
         code: 'PO044',

package/package.json

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

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

@@ -6,4 +6,9 @@ export const AnalyzeCreatePreOrdersFromStandingOrdersResponseDataAnalysesMapping
     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

@@ -2,9 +2,11 @@ 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

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

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/index.ts

@@ -16,6 +16,8 @@ export * from './group-copy-pre-orders-to-collection-response-data-created.schem
 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';
@@ -23,5 +25,15 @@ 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-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/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(),
+});