@floristcloud/api-lib 1.2.176 → 1.2.177

package/build/schemas/pre-order/pre-order-conversion-mapping.schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionMappingSchema = void 0;
+const pre_order_conversion_remainder_schema_1 = require("./pre-order-conversion-remainder.schema");
+const zod_1 = require("zod");
+const pre_order_product_schema_1 = require("../pre-order-product/pre-order-product.schema");
+const pre_order_conversion_match_schema_1 = require("./pre-order-conversion-match.schema");
+exports.PreOrderConversionMappingSchema = zod_1.z.object({
+    item: pre_order_product_schema_1.PreOrderProductExtendedSchema,
+    matches: zod_1.z.array(pre_order_conversion_match_schema_1.PreOrderConversionMatchSchema),
+    warnings: zod_1.z.array(zod_1.z.string()),
+    remainder: pre_order_conversion_remainder_schema_1.PreOrderConversionRemainderSchema.array().optional(),
+    remainingQuantity: zod_1.z.number(),
+});

package/build/schemas/pre-order/pre-order-conversion-match-description.schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionMatchDescriptionSchema = void 0;
+const pre_order_conversion_allocation_schema_1 = require("./pre-order-conversion-allocation.schema");
+exports.PreOrderConversionMatchDescriptionSchema = pre_order_conversion_allocation_schema_1.PreOrderConversionAllocationSchema.pick({
+    kind: true,
+    differences: true,
+    warnings: true,
+});

package/build/schemas/pre-order/pre-order-conversion-match.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionMatchSchema = void 0;
+const pre_order_conversion_match_description_schema_1 = require("./pre-order-conversion-match-description.schema");
+const zod_1 = require("zod");
+const product_extended_for_admin_schema_1 = require("../product/product-extended-for-admin.schema");
+exports.PreOrderConversionMatchSchema = zod_1.z.object({
+    product: product_extended_for_admin_schema_1.ProductExtendedForAdminSchema,
+    quantity: zod_1.z.number(),
+    description: pre_order_conversion_match_description_schema_1.PreOrderConversionMatchDescriptionSchema.optional(),
+    price: zod_1.z.string().optional(),
+    remainingBalance: zod_1.z.number(),
+});

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionOrderSchema = void 0;
+const zod_1 = require("zod");
+const order_schema_1 = require("../order/order.schema");
+exports.PreOrderConversionOrderSchema = order_schema_1.OrderSchema.extend({ warnings: zod_1.z.string().array() });

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionPlanEntrySchema = void 0;
+const zod_1 = require("zod");
+const pre_order_conversion_plan_line_schema_1 = require("./pre-order-conversion-plan-line.schema");
+exports.PreOrderConversionPlanEntrySchema = zod_1.z.object({
+    preOrderUUID: zod_1.z.uuid(),
+    version: zod_1.z.string().min(1),
+    lines: pre_order_conversion_plan_line_schema_1.PreOrderConversionPlanLineSchema.array(),
+});

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

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

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionPreviewPlanEntrySchema = void 0;
+const pre_order_conversion_plan_entry_schema_1 = require("./pre-order-conversion-plan-entry.schema");
+exports.PreOrderConversionPreviewPlanEntrySchema = pre_order_conversion_plan_entry_schema_1.PreOrderConversionPlanEntrySchema.omit({ version: true });

package/build/schemas/pre-order/pre-order-conversion-remainder.schema.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionRemainderSchema = void 0;
+const pre_order_conversion_remainder_reason_enum_1 = require("../../enum/pre-order-conversion-remainder-reason.enum");
+const zod_1 = require("zod");
+exports.PreOrderConversionRemainderSchema = zod_1.z.object({
+    reason: zod_1.z.enum(pre_order_conversion_remainder_reason_enum_1.PreOrderConversionRemainderReasonEnum),
+    quantity: zod_1.z.number().int().nonnegative(),
+});

package/build/schemas/pre-order/pre-order-conversion-skipped.schema.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionSkippedSchema = void 0;
+const pre_order_conversion_skip_reason_enum_1 = require("../../enum/pre-order-conversion-skip-reason.enum");
+const zod_1 = require("zod");
+exports.PreOrderConversionSkippedSchema = zod_1.z.object({ preOrderUUID: zod_1.z.uuid(), reason: zod_1.z.enum(pre_order_conversion_skip_reason_enum_1.PreOrderConversionSkipReasonEnum) });

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionSummaryLineSchema = void 0;
+const zod_1 = require("zod");
+const money_schema_1 = require("../money.schema");
+const pre_order_conversion_attributes_schema_1 = require("./pre-order-conversion-attributes.schema");
+const pre_order_conversion_remainder_schema_1 = require("./pre-order-conversion-remainder.schema");
+const pre_order_conversion_allocation_schema_1 = require("./pre-order-conversion-allocation.schema");
+exports.PreOrderConversionSummaryLineSchema = zod_1.z.object({
+    preOrderProductUUID: zod_1.z.uuid(),
+    requested: pre_order_conversion_attributes_schema_1.PreOrderConversionAttributesSchema,
+    comment: zod_1.z.string().nullable(),
+    stopPrice: money_schema_1.MoneySchema.nullable(),
+    isReplaceable: zod_1.z.boolean(),
+    requestedQuantity: zod_1.z.number().int().nonnegative(),
+    allocatedQuantity: zod_1.z.number().int().nonnegative(),
+    closedQuantity: zod_1.z.number().int().nonnegative(),
+    remainder: pre_order_conversion_remainder_schema_1.PreOrderConversionRemainderSchema.array(),
+    allocations: pre_order_conversion_allocation_schema_1.PreOrderConversionAllocationSchema.array(),
+});

package/build/schemas/pre-order/pre-order-conversion-summary.schema.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionSummarySchema = void 0;
+const zod_1 = require("zod");
+const pre_order_status_enum_1 = require("../../enum/pre-order-status.enum");
+const pre_order_conversion_summary_line_schema_1 = require("./pre-order-conversion-summary-line.schema");
+exports.PreOrderConversionSummarySchema = zod_1.z.object({
+    version: zod_1.z.literal(1),
+    convertedAt: zod_1.z.iso.datetime(),
+    creatorUserUUID: zod_1.z.uuid(),
+    // Статус до оформления — в него предзаказ вернётся при откате. В ранних снимках поля нет.
+    previousStatus: zod_1.z.enum(pre_order_status_enum_1.PreOrderStatusEnum).optional(),
+    lines: pre_order_conversion_summary_line_schema_1.PreOrderConversionSummaryLineSchema.array(),
+});

package/build/schemas/pre-order/pre-order-for-client.schema.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PreOrderForClientSchema = void 0;
+const pre_order_fulfillment_schema_1 = require("./pre-order-fulfillment.schema");
 const zod_1 = require("zod");
 const enum_1 = require("../../enum");
 exports.PreOrderForClientSchema = zod_1.z.object({
+    fulfillment: zod_1.z.record(zod_1.z.uuid(), pre_order_fulfillment_schema_1.PreOrderFulfillmentSchema).nullable().optional(),
+    orderNumbers: zod_1.z.number().int().array().optional(),
+    hasUnavailableOrders: zod_1.z.boolean().optional(),
     uuid: zod_1.z.string(),
     clientUUID: zod_1.z.string(),
     branchUUID: zod_1.z.string().nullable(),

package/build/schemas/pre-order/pre-order-fulfillment-stop-price.schema.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderFulfillmentStopPriceSchema = void 0;
+const zod_1 = require("zod");
+const money_schema_1 = require("../money.schema");
+exports.PreOrderFulfillmentStopPriceSchema = zod_1.z.object({ limit: money_schema_1.MoneySchema, prices: money_schema_1.MoneySchema.array(), currency: zod_1.z.string() });

package/build/schemas/pre-order/pre-order-fulfillment-substitute.schema.js

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

package/build/schemas/pre-order/pre-order-fulfillment.schema.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderFulfillmentSchema = void 0;
+const zod_1 = require("zod");
+const pre_order_fulfillment_status_enum_1 = require("../../enum/pre-order-fulfillment-status.enum");
+const pre_order_conversion_attributes_schema_1 = require("./pre-order-conversion-attributes.schema");
+const pre_order_fulfillment_substitute_schema_1 = require("./pre-order-fulfillment-substitute.schema");
+const pre_order_fulfillment_stop_price_schema_1 = require("./pre-order-fulfillment-stop-price.schema");
+exports.PreOrderFulfillmentSchema = zod_1.z.object({
+    status: zod_1.z.enum(pre_order_fulfillment_status_enum_1.PreOrderFulfillmentStatusEnum),
+    allocated: zod_1.z.number().int().nonnegative(),
+    requested: zod_1.z.number().int().nonnegative(),
+    requestedAttributes: pre_order_conversion_attributes_schema_1.PreOrderConversionAttributesSchema.nullable(),
+    substitutes: pre_order_fulfillment_substitute_schema_1.PreOrderFulfillmentSubstituteSchema.array(),
+    stopPrice: pre_order_fulfillment_stop_price_schema_1.PreOrderFulfillmentStopPriceSchema.nullable(),
+});

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

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdatePreOrderWebshopSchema = exports.CreatePreOrderWebshopSchema = exports.UpdatePreOrderSchema = exports.UpdatablePreOrderStatusSchema = exports.CreatePreOrderSchema = exports.PreOrderListSchema = exports.PreOrderWithClientSchema = exports.PreOrderExtendedSchema = exports.PreOrderSchema = void 0;
+const pre_order_conversion_current_order_schema_1 = require("./pre-order-conversion-current-order.schema");
+const pre_order_conversion_change_schema_1 = require("./pre-order-conversion-change.schema");
+const pre_order_conversion_summary_schema_1 = require("./pre-order-conversion-summary.schema");
 const zod_1 = require("zod");
 const pre_order_status_enum_1 = require("../../enum/pre-order-status.enum");
 const client_base_schema_1 = require("../client/client-base.schema");
@@ -8,6 +11,9 @@ const branch_schema_1 = require("../branch/branch.schema");
 const pre_order_collection_schema_1 = require("../pre-order-collection/pre-order-collection.schema");
 const money_schema_1 = require("../money.schema");
 exports.PreOrderSchema = zod_1.z.object({
+    conversionOrders: pre_order_conversion_current_order_schema_1.PreOrderConversionCurrentOrderSchema.array().optional(),
+    conversionChanges: pre_order_conversion_change_schema_1.PreOrderConversionChangeSchema.array().optional(),
+    conversionSummary: pre_order_conversion_summary_schema_1.PreOrderConversionSummarySchema.nullable().optional(),
     uuid: zod_1.z.string(),
     clientUUID: zod_1.z.string(),
     branchUUID: zod_1.z.string().nullable(),
@@ -53,7 +59,14 @@ exports.UpdatablePreOrderStatusSchema = zod_1.z.enum([
     pre_order_status_enum_1.PreOrderStatusEnum.VERIFIED,
     pre_order_status_enum_1.PreOrderStatusEnum.COMPLETED,
 ]);
-exports.UpdatePreOrderSchema = exports.PreOrderSchema.omit({ uuid: true, preOrderNum: true, createdAt: true })
+exports.UpdatePreOrderSchema = exports.PreOrderSchema.omit({
+    uuid: true,
+    preOrderNum: true,
+    createdAt: true,
+    conversionOrders: true,
+    conversionSummary: true,
+    conversionChanges: true,
+})
     .partial()
     .extend({ status: exports.UpdatablePreOrderStatusSchema.optional() });
 exports.CreatePreOrderWebshopSchema = exports.PreOrderSchema.pick({ branchUUID: true, comment: true }).extend({

package/build/schemas/pre-order/revert-pre-order-conversion-order.schema.js

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

package/build/schemas/pre-order/revert-pre-order-conversion-response.schema.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevertPreOrderConversionResponseSchema = void 0;
+const zod_1 = require("zod");
+const revert_pre_order_conversion_result_schema_1 = require("./revert-pre-order-conversion-result.schema");
+exports.RevertPreOrderConversionResponseSchema = zod_1.z.object({
+    data: revert_pre_order_conversion_result_schema_1.RevertPreOrderConversionResultSchema,
+});

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevertPreOrderConversionResultSchema = void 0;
+const zod_1 = require("zod");
+const pre_order_status_enum_1 = require("../../enum/pre-order-status.enum");
+const revert_pre_order_conversion_order_schema_1 = require("./revert-pre-order-conversion-order.schema");
+exports.RevertPreOrderConversionResultSchema = zod_1.z.object({
+    status: zod_1.z.enum(pre_order_status_enum_1.PreOrderStatusEnum),
+    deletedOrders: revert_pre_order_conversion_order_schema_1.RevertPreOrderConversionOrderSchema.array(),
+});

package/build/schemas/pre-order/update-pre-order-webshop-response.schema.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePreOrderWebshopResponseSchema = void 0;
+const zod_1 = require("zod");
+const pre_order_for_client_schema_1 = require("./pre-order-for-client.schema");
+exports.UpdatePreOrderWebshopResponseSchema = zod_1.z.object({ message: zod_1.z.string().optional(), data: pre_order_for_client_schema_1.PreOrderForClientSchema });

package/commands/pre-order/get-pre-order-by-pre-order-collection-uuid.command.ts

@@ -1,11 +1,7 @@
-import { z } from 'zod';
-import { PreOrderSchema } from '../../schemas';
-
-const GetPreOrderResponseSchema = z.object({
-    data: PreOrderSchema,
-});
+import type { z } from 'zod';
+import { GetPreOrderByCollectionForClientResponseSchema } from '../../schemas/pre-order/get-pre-order-by-collection-for-client-response.schema';
 
 export namespace GetPreOrderByPreOrderCollectionUuidContractCommand {
-    export const ResponseSchema = GetPreOrderResponseSchema;
+    export const ResponseSchema = GetPreOrderByCollectionForClientResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

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

@@ -1,52 +1,6 @@
-import { z } from 'zod';
-import {
-    MatchingConfigSchema,
-    PreOrderProductExtendedSchema,
-    PreOrderWithClientSchema,
-    ProductExtendedForAdminSchema,
-} from '../../../schemas';
-
-const AnalyzeCreateOrdersFromPreOrdersRequestSchema = z.object({
-    preOrderUUIDs: z.uuid().array(),
-    consignmentUUIDs: z.uuid().array(),
-    matchingConfig: MatchingConfigSchema.optional().nullable(),
-    isProportionalAllocation: z.coerce.boolean().optional(),
-});
-
-const AnalyzeCreateOrdersFromPreOrdersResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        analyses: z.array(
-            z.object({
-                preOrder: PreOrderWithClientSchema,
-                mappings: z.record(
-                    z.string(),
-                    z.object({
-                        item: PreOrderProductExtendedSchema,
-                        matches: z.array(
-                            z.object({
-                                product: ProductExtendedForAdminSchema,
-                                quantity: z.number(),
-                                remainingBalance: z.number(),
-                            }),
-                        ),
-                        warnings: z.array(z.string()),
-                        remainingQuantity: z.number(),
-                    }),
-                ),
-                warnings: z.array(z.string()),
-            }),
-        ),
-        errorList: z
-            .array(
-                z.object({
-                    code: z.string(),
-                    message: z.string(),
-                }),
-            )
-            .optional(),
-    }),
-});
+import type { z } from 'zod';
+import { AnalyzeCreateOrdersFromPreOrdersRequestSchema } from '../../../schemas/pre-order/analyze-create-orders-from-pre-orders-request.schema';
+import { AnalyzeCreateOrdersFromPreOrdersResponseSchema } from '../../../schemas/pre-order/analyze-create-orders-from-pre-orders-response.schema';
 
 export namespace AnalyzeCreateOrdersFromPreOrdersContractCommand {
     export const RequestSchema = AnalyzeCreateOrdersFromPreOrdersRequestSchema;

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

@@ -1,54 +1,6 @@
-import { z } from 'zod';
-import { MatchingConfigSchema, OrderSchema } from '../../../schemas';
-
-const GroupCreateOrdersFromPreOrdersRequestSchema = z.object({
-    preOrderUUIDs: z.uuid().array(),
-    consignmentUUIDs: z.uuid().array(),
-    matchingConfig: MatchingConfigSchema.optional().nullable(),
-    isProportionalAllocation: z.coerce.boolean().optional(),
-    orderProductTag: z.string().nullable().optional(),
-    /**
-     * The conversion the user confirmed in the preview. Without it the server re-runs the analysis
-     * and converts whatever it finds at that moment; with it the analysis is skipped and exactly
-     * these allocations are created. Carries product choice and quantity only — prices always stay
-     * server-side (product price + discount rules).
-     */
-    plan: z
-        .object({
-            preOrderUUID: z.uuid(),
-            lines: z
-                .object({
-                    preOrderProductUUID: z.uuid(),
-                    allocations: z.object({ productUUID: z.uuid(), quantity: z.number().int().positive() }).array(),
-                })
-                .array(),
-        })
-        .array()
-        .optional(),
-});
-
-const GroupCreateOrdersFromPreOrdersResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        created: z
-            .object({
-                preOrderUUID: z.uuid(),
-                orders: OrderSchema.extend({
-                    warnings: z.string().array(),
-                }).array(),
-            })
-            .array(),
-        failed: z
-            .object({
-                preOrderUUID: z.uuid(),
-                error: z.object({
-                    code: z.string(),
-                    message: z.string(),
-                }),
-            })
-            .array(),
-    }),
-});
+import type { z } from 'zod';
+import { GroupCreateOrdersFromPreOrdersRequestSchema } from '../../../schemas/pre-order/group-create-orders-from-pre-orders-request.schema';
+import { GroupCreateOrdersFromPreOrdersResponseSchema } from '../../../schemas/pre-order/group-create-orders-from-pre-orders-response.schema';
 
 export namespace GroupCreateOrdersFromPreOrdersContractCommand {
     export const RequestSchema = GroupCreateOrdersFromPreOrdersRequestSchema;

package/commands/pre-order/index.ts

@@ -11,3 +11,4 @@ export * from './create-order-from-pre-order.command';
 export * from './import-standing-order.command';
 export * from './get-standing-order-import-template.command';
 export * from './export-pre-order.command';
+export * from './revert-pre-order-conversion.command';

package/commands/pre-order/revert-pre-order-conversion.command.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { RevertPreOrderConversionResponseSchema } from '../../schemas/pre-order/revert-pre-order-conversion-response.schema';
+
+export namespace RevertPreOrderConversionContractCommand {
+    export const ResponseSchema = RevertPreOrderConversionResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order/webshop/checkout-pre-order-webshop.command.ts

@@ -1,17 +1,6 @@
-import { z } from 'zod';
-import { PreOrderSchema } from '../../../schemas';
-
-const CheckoutPreOrderWebshopRequestSchema = z
-    .object({
-        comment: z.string().nullable().optional(),
-        branchUUID: z.string().nullable().optional(),
-    })
-    .default({});
-
-const CheckoutPreOrderWebshopResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderSchema,
-});
+import { CheckoutPreOrderWebshopRequestSchema } from '../../../schemas/pre-order/checkout-pre-order-webshop-request.schema';
+import { CheckoutPreOrderWebshopResponseSchema } from '../../../schemas/pre-order/checkout-pre-order-webshop-response.schema';
+import type { z } from 'zod';
 
 export namespace CheckoutPreOrderWebshopContractCommand {
     export const RequestSchema = CheckoutPreOrderWebshopRequestSchema;

package/commands/pre-order/webshop/create-pre-order-webshop.command.ts

@@ -1,10 +1,6 @@
-import { z } from 'zod';
-import { CreatePreOrderWebshopSchema, PreOrderSchema } from '../../../schemas';
-
-const CreatePreOrderWebshopResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderSchema,
-});
+import { CreatePreOrderWebshopResponseSchema } from '../../../schemas/pre-order/create-pre-order-webshop-response.schema';
+import type { z } from 'zod';
+import { CreatePreOrderWebshopSchema } from '../../../schemas';
 
 export namespace CreatePreOrderWebshopContractCommand {
     export const RequestSchema = CreatePreOrderWebshopSchema;

package/commands/pre-order/webshop/update-pre-order-webshop.command.ts

@@ -1,10 +1,6 @@
-import { z } from 'zod';
-import { UpdatePreOrderWebshopSchema, PreOrderSchema } from '../../../schemas';
-
-const UpdatePreOrderWebshopResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderSchema,
-});
+import { UpdatePreOrderWebshopResponseSchema } from '../../../schemas/pre-order/update-pre-order-webshop-response.schema';
+import type { z } from 'zod';
+import { UpdatePreOrderWebshopSchema } from '../../../schemas';
 
 export namespace UpdatePreOrderWebshopContractCommand {
     export const RequestSchema = UpdatePreOrderWebshopSchema;

package/constant/error.ts

@@ -1112,6 +1112,41 @@ export const ERRORS = {
         message: 'Failed to create standing-order position from pre-order position',
         httpCode: 400,
     },
+    PRE_ORDER_ALREADY_CONVERTED: {
+        code: 'PO059',
+        message: 'The pre-order has already been converted into orders.',
+        httpCode: 409,
+    },
+    PRE_ORDER_NOTHING_MATCHED: {
+        code: 'PO057',
+        message: 'Nothing matched; the pre-order remains open.',
+        httpCode: 400,
+    },
+    PRE_ORDER_CLOSE_REMAINDER_CONFIRMATION_REQUIRED: {
+        code: 'PO058',
+        message: 'Confirm closing the unallocated remainder before conversion.',
+        httpCode: 400,
+    },
+    PRE_ORDER_NOT_CONVERTED: {
+        code: 'PO060',
+        message: 'The pre-order has not been converted into orders.',
+        httpCode: 409,
+    },
+    PRE_ORDER_CONVERSION_REVERT_ORDERS_IN_WORK: {
+        code: 'PO061',
+        message: 'Orders from this conversion are already in work, so the conversion cannot be reverted.',
+        httpCode: 409,
+    },
+    PRE_ORDER_CONVERSION_REVERT_ROWS_MOVED: {
+        code: 'PO062',
+        message: 'Goods from this conversion were moved to other orders, so the conversion cannot be reverted.',
+        httpCode: 409,
+    },
+    PRE_ORDER_CONVERSION_SUMMARY_UNREADABLE: {
+        code: 'PO063',
+        message: 'The conversion snapshot cannot be read, so the orders to delete are unknown.',
+        httpCode: 409,
+    },
     PRE_ORDER_CONVERSION_ANALYSIS_STALE: {
         code: 'PO048',
         message: 'The pre-order changed after the conversion analysis, analyze it again',

package/enum/index.ts

@@ -152,3 +152,10 @@ export * from './write-off-status.enum';
 export * from './one-c-stock-conflict-status.enum';
 export * from './one-c-stock-conflict-line-action.enum';
 export * from './one-c-stock-conflict-line-restriction.enum';
+export * from './pre-order-conversion-match-kind.enum';
+export * from './pre-order-conversion-warning.enum';
+export * from './pre-order-conversion-remainder-reason.enum';
+export * from './pre-order-conversion-difference-field.enum';
+export * from './pre-order-conversion-skip-reason.enum';
+
+export * from './pre-order-fulfillment-status.enum';

package/enum/pre-order-conversion-difference-field.enum.ts

@@ -0,0 +1,7 @@
+export enum PreOrderConversionDifferenceFieldEnum {
+    NAME = 'name',
+    SIZE = 'size',
+    COLOR = 'color',
+    GROWER = 'grower',
+    CATEGORY = 'categoryUUID',
+}

package/enum/pre-order-conversion-match-kind.enum.ts

@@ -0,0 +1,4 @@
+export enum PreOrderConversionMatchKindEnum {
+    EXACT = 'EXACT',
+    SUBSTITUTE = 'SUBSTITUTE',
+}

package/enum/pre-order-conversion-remainder-reason.enum.ts

@@ -0,0 +1,6 @@
+export enum PreOrderConversionRemainderReasonEnum {
+    NO_MATCH = 'NO_MATCH',
+    INSUFFICIENT_STOCK = 'INSUFFICIENT_STOCK',
+    MULTIPLICITY = 'MULTIPLICITY',
+    EXCLUDED_BY_EMPLOYEE = 'EXCLUDED_BY_EMPLOYEE',
+}

package/enum/pre-order-conversion-skip-reason.enum.ts

@@ -0,0 +1,3 @@
+export enum PreOrderConversionSkipReasonEnum {
+    NOTHING_MATCHED = 'NOTHING_MATCHED',
+}

package/enum/pre-order-conversion-warning.enum.ts

@@ -0,0 +1,4 @@
+export enum PreOrderConversionWarningEnum {
+    STOP_PRICE_EXCEEDED = 'STOP_PRICE_EXCEEDED',
+    REPLACEMENT_NOT_ALLOWED = 'REPLACEMENT_NOT_ALLOWED',
+}

package/enum/pre-order-fulfillment-status.enum.ts

@@ -0,0 +1,6 @@
+export enum PreOrderFulfillmentStatusEnum {
+    FULL = 'FULL',
+    PARTIAL = 'PARTIAL',
+    NOT_MATCHED = 'NOT_MATCHED',
+    NOT_IN_CONVERSION = 'NOT_IN_CONVERSION',
+}

package/package.json

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

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

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { PreOrderConversionAnalysisSchema } from './pre-order-conversion-analysis.schema';
+import { PreOrderConversionErrorSchema } from './pre-order-conversion-error.schema';
+
+export const AnalyzeCreateOrdersFromPreOrdersDataSchema = z.object({
+    analyses: z.array(PreOrderConversionAnalysisSchema),
+    errorList: z.array(PreOrderConversionErrorSchema).optional(),
+});

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

@@ -0,0 +1,11 @@
+import { PreOrderConversionPreviewPlanEntrySchema } from './pre-order-conversion-preview-plan-entry.schema';
+import { z } from 'zod';
+import { MatchingConfigSchema } from '../pre-order-product/matching-config.schema';
+
+export const AnalyzeCreateOrdersFromPreOrdersRequestSchema = z.object({
+    plan: PreOrderConversionPreviewPlanEntrySchema.array().optional(),
+    preOrderUUIDs: z.uuid().array(),
+    consignmentUUIDs: z.uuid().array(),
+    matchingConfig: MatchingConfigSchema.optional().nullable(),
+    isProportionalAllocation: z.coerce.boolean().optional(),
+});

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

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

package/schemas/pre-order/checkout-pre-order-webshop-request.schema.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+export const CheckoutPreOrderWebshopRequestSchema = z
+    .object({ comment: z.string().nullable().optional(), branchUUID: z.string().nullable().optional() })
+    .default({});

package/schemas/pre-order/checkout-pre-order-webshop-response.schema.ts

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

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

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

package/schemas/pre-order/get-pre-order-by-collection-for-client-response.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import { PreOrderForClientSchema } from './pre-order-for-client.schema';
+export const GetPreOrderByCollectionForClientResponseSchema = z.object({ data: PreOrderForClientSchema });