@floristcloud/api-lib 1.2.176 → 1.2.177

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

@@ -1,12 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetPreOrderByPreOrderCollectionUuidContractCommand = void 0;
-const zod_1 = require("zod");
-const schemas_1 = require("../../schemas");
-const GetPreOrderResponseSchema = zod_1.z.object({
-    data: schemas_1.PreOrderSchema,
-});
+const get_pre_order_by_collection_for_client_response_schema_1 = require("../../schemas/pre-order/get-pre-order-by-collection-for-client-response.schema");
 var GetPreOrderByPreOrderCollectionUuidContractCommand;
 (function (GetPreOrderByPreOrderCollectionUuidContractCommand) {
-    GetPreOrderByPreOrderCollectionUuidContractCommand.ResponseSchema = GetPreOrderResponseSchema;
+    GetPreOrderByPreOrderCollectionUuidContractCommand.ResponseSchema = get_pre_order_by_collection_for_client_response_schema_1.GetPreOrderByCollectionForClientResponseSchema;
 })(GetPreOrderByPreOrderCollectionUuidContractCommand || (exports.GetPreOrderByPreOrderCollectionUuidContractCommand = GetPreOrderByPreOrderCollectionUuidContractCommand = {}));

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

@@ -1,41 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalyzeCreateOrdersFromPreOrdersContractCommand = void 0;
-const zod_1 = require("zod");
-const schemas_1 = require("../../../schemas");
-const AnalyzeCreateOrdersFromPreOrdersRequestSchema = zod_1.z.object({
-    preOrderUUIDs: zod_1.z.uuid().array(),
-    consignmentUUIDs: zod_1.z.uuid().array(),
-    matchingConfig: schemas_1.MatchingConfigSchema.optional().nullable(),
-    isProportionalAllocation: zod_1.z.coerce.boolean().optional(),
-});
-const AnalyzeCreateOrdersFromPreOrdersResponseSchema = zod_1.z.object({
-    message: zod_1.z.string().optional(),
-    data: zod_1.z.object({
-        analyses: zod_1.z.array(zod_1.z.object({
-            preOrder: schemas_1.PreOrderWithClientSchema,
-            mappings: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
-                item: schemas_1.PreOrderProductExtendedSchema,
-                matches: zod_1.z.array(zod_1.z.object({
-                    product: schemas_1.ProductExtendedForAdminSchema,
-                    quantity: zod_1.z.number(),
-                    remainingBalance: zod_1.z.number(),
-                })),
-                warnings: zod_1.z.array(zod_1.z.string()),
-                remainingQuantity: zod_1.z.number(),
-            })),
-            warnings: zod_1.z.array(zod_1.z.string()),
-        })),
-        errorList: zod_1.z
-            .array(zod_1.z.object({
-            code: zod_1.z.string(),
-            message: zod_1.z.string(),
-        }))
-            .optional(),
-    }),
-});
+const analyze_create_orders_from_pre_orders_request_schema_1 = require("../../../schemas/pre-order/analyze-create-orders-from-pre-orders-request.schema");
+const analyze_create_orders_from_pre_orders_response_schema_1 = require("../../../schemas/pre-order/analyze-create-orders-from-pre-orders-response.schema");
 var AnalyzeCreateOrdersFromPreOrdersContractCommand;
 (function (AnalyzeCreateOrdersFromPreOrdersContractCommand) {
-    AnalyzeCreateOrdersFromPreOrdersContractCommand.RequestSchema = AnalyzeCreateOrdersFromPreOrdersRequestSchema;
-    AnalyzeCreateOrdersFromPreOrdersContractCommand.ResponseSchema = AnalyzeCreateOrdersFromPreOrdersResponseSchema;
+    AnalyzeCreateOrdersFromPreOrdersContractCommand.RequestSchema = analyze_create_orders_from_pre_orders_request_schema_1.AnalyzeCreateOrdersFromPreOrdersRequestSchema;
+    AnalyzeCreateOrdersFromPreOrdersContractCommand.ResponseSchema = analyze_create_orders_from_pre_orders_response_schema_1.AnalyzeCreateOrdersFromPreOrdersResponseSchema;
 })(AnalyzeCreateOrdersFromPreOrdersContractCommand || (exports.AnalyzeCreateOrdersFromPreOrdersContractCommand = AnalyzeCreateOrdersFromPreOrdersContractCommand = {}));

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

@@ -1,57 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GroupCreateOrdersFromPreOrdersContractCommand = void 0;
-const zod_1 = require("zod");
-const schemas_1 = require("../../../schemas");
-const GroupCreateOrdersFromPreOrdersRequestSchema = zod_1.z.object({
-    preOrderUUIDs: zod_1.z.uuid().array(),
-    consignmentUUIDs: zod_1.z.uuid().array(),
-    matchingConfig: schemas_1.MatchingConfigSchema.optional().nullable(),
-    isProportionalAllocation: zod_1.z.coerce.boolean().optional(),
-    orderProductTag: zod_1.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: zod_1.z
-        .object({
-        preOrderUUID: zod_1.z.uuid(),
-        lines: zod_1.z
-            .object({
-            preOrderProductUUID: zod_1.z.uuid(),
-            allocations: zod_1.z.object({ productUUID: zod_1.z.uuid(), quantity: zod_1.z.number().int().positive() }).array(),
-        })
-            .array(),
-    })
-        .array()
-        .optional(),
-});
-const GroupCreateOrdersFromPreOrdersResponseSchema = zod_1.z.object({
-    message: zod_1.z.string().optional(),
-    data: zod_1.z.object({
-        created: zod_1.z
-            .object({
-            preOrderUUID: zod_1.z.uuid(),
-            orders: schemas_1.OrderSchema.extend({
-                warnings: zod_1.z.string().array(),
-            }).array(),
-        })
-            .array(),
-        failed: zod_1.z
-            .object({
-            preOrderUUID: zod_1.z.uuid(),
-            error: zod_1.z.object({
-                code: zod_1.z.string(),
-                message: zod_1.z.string(),
-            }),
-        })
-            .array(),
-    }),
-});
+const group_create_orders_from_pre_orders_request_schema_1 = require("../../../schemas/pre-order/group-create-orders-from-pre-orders-request.schema");
+const group_create_orders_from_pre_orders_response_schema_1 = require("../../../schemas/pre-order/group-create-orders-from-pre-orders-response.schema");
 var GroupCreateOrdersFromPreOrdersContractCommand;
 (function (GroupCreateOrdersFromPreOrdersContractCommand) {
-    GroupCreateOrdersFromPreOrdersContractCommand.RequestSchema = GroupCreateOrdersFromPreOrdersRequestSchema;
-    GroupCreateOrdersFromPreOrdersContractCommand.ResponseSchema = GroupCreateOrdersFromPreOrdersResponseSchema;
+    GroupCreateOrdersFromPreOrdersContractCommand.RequestSchema = group_create_orders_from_pre_orders_request_schema_1.GroupCreateOrdersFromPreOrdersRequestSchema;
+    GroupCreateOrdersFromPreOrdersContractCommand.ResponseSchema = group_create_orders_from_pre_orders_response_schema_1.GroupCreateOrdersFromPreOrdersResponseSchema;
 })(GroupCreateOrdersFromPreOrdersContractCommand || (exports.GroupCreateOrdersFromPreOrdersContractCommand = GroupCreateOrdersFromPreOrdersContractCommand = {}));

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

@@ -27,3 +27,4 @@ __exportStar(require("./create-order-from-pre-order.command"), exports);
 __exportStar(require("./import-standing-order.command"), exports);
 __exportStar(require("./get-standing-order-import-template.command"), exports);
 __exportStar(require("./export-pre-order.command"), exports);
+__exportStar(require("./revert-pre-order-conversion.command"), exports);

package/build/commands/pre-order/revert-pre-order-conversion.command.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevertPreOrderConversionContractCommand = void 0;
+const revert_pre_order_conversion_response_schema_1 = require("../../schemas/pre-order/revert-pre-order-conversion-response.schema");
+var RevertPreOrderConversionContractCommand;
+(function (RevertPreOrderConversionContractCommand) {
+    RevertPreOrderConversionContractCommand.ResponseSchema = revert_pre_order_conversion_response_schema_1.RevertPreOrderConversionResponseSchema;
+})(RevertPreOrderConversionContractCommand || (exports.RevertPreOrderConversionContractCommand = RevertPreOrderConversionContractCommand = {}));

package/build/commands/pre-order/webshop/checkout-pre-order-webshop.command.js

@@ -1,20 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CheckoutPreOrderWebshopContractCommand = void 0;
-const zod_1 = require("zod");
-const schemas_1 = require("../../../schemas");
-const CheckoutPreOrderWebshopRequestSchema = zod_1.z
-    .object({
-    comment: zod_1.z.string().nullable().optional(),
-    branchUUID: zod_1.z.string().nullable().optional(),
-})
-    .default({});
-const CheckoutPreOrderWebshopResponseSchema = zod_1.z.object({
-    message: zod_1.z.string().optional(),
-    data: schemas_1.PreOrderSchema,
-});
+const checkout_pre_order_webshop_request_schema_1 = require("../../../schemas/pre-order/checkout-pre-order-webshop-request.schema");
+const checkout_pre_order_webshop_response_schema_1 = require("../../../schemas/pre-order/checkout-pre-order-webshop-response.schema");
 var CheckoutPreOrderWebshopContractCommand;
 (function (CheckoutPreOrderWebshopContractCommand) {
-    CheckoutPreOrderWebshopContractCommand.RequestSchema = CheckoutPreOrderWebshopRequestSchema;
-    CheckoutPreOrderWebshopContractCommand.ResponseSchema = CheckoutPreOrderWebshopResponseSchema;
+    CheckoutPreOrderWebshopContractCommand.RequestSchema = checkout_pre_order_webshop_request_schema_1.CheckoutPreOrderWebshopRequestSchema;
+    CheckoutPreOrderWebshopContractCommand.ResponseSchema = checkout_pre_order_webshop_response_schema_1.CheckoutPreOrderWebshopResponseSchema;
 })(CheckoutPreOrderWebshopContractCommand || (exports.CheckoutPreOrderWebshopContractCommand = CheckoutPreOrderWebshopContractCommand = {}));

package/build/commands/pre-order/webshop/create-pre-order-webshop.command.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreatePreOrderWebshopContractCommand = void 0;
-const zod_1 = require("zod");
+const create_pre_order_webshop_response_schema_1 = require("../../../schemas/pre-order/create-pre-order-webshop-response.schema");
 const schemas_1 = require("../../../schemas");
-const CreatePreOrderWebshopResponseSchema = zod_1.z.object({
-    message: zod_1.z.string().optional(),
-    data: schemas_1.PreOrderSchema,
-});
 var CreatePreOrderWebshopContractCommand;
 (function (CreatePreOrderWebshopContractCommand) {
     CreatePreOrderWebshopContractCommand.RequestSchema = schemas_1.CreatePreOrderWebshopSchema;
-    CreatePreOrderWebshopContractCommand.ResponseSchema = CreatePreOrderWebshopResponseSchema;
+    CreatePreOrderWebshopContractCommand.ResponseSchema = create_pre_order_webshop_response_schema_1.CreatePreOrderWebshopResponseSchema;
 })(CreatePreOrderWebshopContractCommand || (exports.CreatePreOrderWebshopContractCommand = CreatePreOrderWebshopContractCommand = {}));

package/build/commands/pre-order/webshop/update-pre-order-webshop.command.js

@@ -1,14 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UpdatePreOrderWebshopContractCommand = void 0;
-const zod_1 = require("zod");
+const update_pre_order_webshop_response_schema_1 = require("../../../schemas/pre-order/update-pre-order-webshop-response.schema");
 const schemas_1 = require("../../../schemas");
-const UpdatePreOrderWebshopResponseSchema = zod_1.z.object({
-    message: zod_1.z.string().optional(),
-    data: schemas_1.PreOrderSchema,
-});
 var UpdatePreOrderWebshopContractCommand;
 (function (UpdatePreOrderWebshopContractCommand) {
     UpdatePreOrderWebshopContractCommand.RequestSchema = schemas_1.UpdatePreOrderWebshopSchema;
-    UpdatePreOrderWebshopContractCommand.ResponseSchema = UpdatePreOrderWebshopResponseSchema;
+    UpdatePreOrderWebshopContractCommand.ResponseSchema = update_pre_order_webshop_response_schema_1.UpdatePreOrderWebshopResponseSchema;
 })(UpdatePreOrderWebshopContractCommand || (exports.UpdatePreOrderWebshopContractCommand = UpdatePreOrderWebshopContractCommand = {}));

package/build/constant/error.js

@@ -1076,6 +1076,41 @@ exports.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/build/enum/index.js

@@ -168,3 +168,9 @@ __exportStar(require("./write-off-status.enum"), exports);
 __exportStar(require("./one-c-stock-conflict-status.enum"), exports);
 __exportStar(require("./one-c-stock-conflict-line-action.enum"), exports);
 __exportStar(require("./one-c-stock-conflict-line-restriction.enum"), exports);
+__exportStar(require("./pre-order-conversion-match-kind.enum"), exports);
+__exportStar(require("./pre-order-conversion-warning.enum"), exports);
+__exportStar(require("./pre-order-conversion-remainder-reason.enum"), exports);
+__exportStar(require("./pre-order-conversion-difference-field.enum"), exports);
+__exportStar(require("./pre-order-conversion-skip-reason.enum"), exports);
+__exportStar(require("./pre-order-fulfillment-status.enum"), exports);

package/build/enum/pre-order-conversion-difference-field.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionDifferenceFieldEnum = void 0;
+var PreOrderConversionDifferenceFieldEnum;
+(function (PreOrderConversionDifferenceFieldEnum) {
+    PreOrderConversionDifferenceFieldEnum["NAME"] = "name";
+    PreOrderConversionDifferenceFieldEnum["SIZE"] = "size";
+    PreOrderConversionDifferenceFieldEnum["COLOR"] = "color";
+    PreOrderConversionDifferenceFieldEnum["GROWER"] = "grower";
+    PreOrderConversionDifferenceFieldEnum["CATEGORY"] = "categoryUUID";
+})(PreOrderConversionDifferenceFieldEnum || (exports.PreOrderConversionDifferenceFieldEnum = PreOrderConversionDifferenceFieldEnum = {}));

package/build/enum/pre-order-conversion-match-kind.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionMatchKindEnum = void 0;
+var PreOrderConversionMatchKindEnum;
+(function (PreOrderConversionMatchKindEnum) {
+    PreOrderConversionMatchKindEnum["EXACT"] = "EXACT";
+    PreOrderConversionMatchKindEnum["SUBSTITUTE"] = "SUBSTITUTE";
+})(PreOrderConversionMatchKindEnum || (exports.PreOrderConversionMatchKindEnum = PreOrderConversionMatchKindEnum = {}));

package/build/enum/pre-order-conversion-remainder-reason.enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionRemainderReasonEnum = void 0;
+var PreOrderConversionRemainderReasonEnum;
+(function (PreOrderConversionRemainderReasonEnum) {
+    PreOrderConversionRemainderReasonEnum["NO_MATCH"] = "NO_MATCH";
+    PreOrderConversionRemainderReasonEnum["INSUFFICIENT_STOCK"] = "INSUFFICIENT_STOCK";
+    PreOrderConversionRemainderReasonEnum["MULTIPLICITY"] = "MULTIPLICITY";
+    PreOrderConversionRemainderReasonEnum["EXCLUDED_BY_EMPLOYEE"] = "EXCLUDED_BY_EMPLOYEE";
+})(PreOrderConversionRemainderReasonEnum || (exports.PreOrderConversionRemainderReasonEnum = PreOrderConversionRemainderReasonEnum = {}));

package/build/enum/pre-order-conversion-skip-reason.enum.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionSkipReasonEnum = void 0;
+var PreOrderConversionSkipReasonEnum;
+(function (PreOrderConversionSkipReasonEnum) {
+    PreOrderConversionSkipReasonEnum["NOTHING_MATCHED"] = "NOTHING_MATCHED";
+})(PreOrderConversionSkipReasonEnum || (exports.PreOrderConversionSkipReasonEnum = PreOrderConversionSkipReasonEnum = {}));

package/build/enum/pre-order-conversion-warning.enum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionWarningEnum = void 0;
+var PreOrderConversionWarningEnum;
+(function (PreOrderConversionWarningEnum) {
+    PreOrderConversionWarningEnum["STOP_PRICE_EXCEEDED"] = "STOP_PRICE_EXCEEDED";
+    PreOrderConversionWarningEnum["REPLACEMENT_NOT_ALLOWED"] = "REPLACEMENT_NOT_ALLOWED";
+})(PreOrderConversionWarningEnum || (exports.PreOrderConversionWarningEnum = PreOrderConversionWarningEnum = {}));

package/build/enum/pre-order-fulfillment-status.enum.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderFulfillmentStatusEnum = void 0;
+var PreOrderFulfillmentStatusEnum;
+(function (PreOrderFulfillmentStatusEnum) {
+    PreOrderFulfillmentStatusEnum["FULL"] = "FULL";
+    PreOrderFulfillmentStatusEnum["PARTIAL"] = "PARTIAL";
+    PreOrderFulfillmentStatusEnum["NOT_MATCHED"] = "NOT_MATCHED";
+    PreOrderFulfillmentStatusEnum["NOT_IN_CONVERSION"] = "NOT_IN_CONVERSION";
+})(PreOrderFulfillmentStatusEnum || (exports.PreOrderFulfillmentStatusEnum = PreOrderFulfillmentStatusEnum = {}));

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzeCreateOrdersFromPreOrdersDataSchema = void 0;
+const zod_1 = require("zod");
+const pre_order_conversion_analysis_schema_1 = require("./pre-order-conversion-analysis.schema");
+const pre_order_conversion_error_schema_1 = require("./pre-order-conversion-error.schema");
+exports.AnalyzeCreateOrdersFromPreOrdersDataSchema = zod_1.z.object({
+    analyses: zod_1.z.array(pre_order_conversion_analysis_schema_1.PreOrderConversionAnalysisSchema),
+    errorList: zod_1.z.array(pre_order_conversion_error_schema_1.PreOrderConversionErrorSchema).optional(),
+});

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzeCreateOrdersFromPreOrdersRequestSchema = void 0;
+const pre_order_conversion_preview_plan_entry_schema_1 = require("./pre-order-conversion-preview-plan-entry.schema");
+const zod_1 = require("zod");
+const matching_config_schema_1 = require("../pre-order-product/matching-config.schema");
+exports.AnalyzeCreateOrdersFromPreOrdersRequestSchema = zod_1.z.object({
+    plan: pre_order_conversion_preview_plan_entry_schema_1.PreOrderConversionPreviewPlanEntrySchema.array().optional(),
+    preOrderUUIDs: zod_1.z.uuid().array(),
+    consignmentUUIDs: zod_1.z.uuid().array(),
+    matchingConfig: matching_config_schema_1.MatchingConfigSchema.optional().nullable(),
+    isProportionalAllocation: zod_1.z.coerce.boolean().optional(),
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzeCreateOrdersFromPreOrdersResponseSchema = void 0;
+const zod_1 = require("zod");
+const analyze_create_orders_from_pre_orders_data_schema_1 = require("./analyze-create-orders-from-pre-orders-data.schema");
+exports.AnalyzeCreateOrdersFromPreOrdersResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: analyze_create_orders_from_pre_orders_data_schema_1.AnalyzeCreateOrdersFromPreOrdersDataSchema,
+});

package/build/schemas/pre-order/checkout-pre-order-webshop-request.schema.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckoutPreOrderWebshopRequestSchema = void 0;
+const zod_1 = require("zod");
+exports.CheckoutPreOrderWebshopRequestSchema = zod_1.z
+    .object({ comment: zod_1.z.string().nullable().optional(), branchUUID: zod_1.z.string().nullable().optional() })
+    .default({});

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

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

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

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

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCreateOrdersFromPreOrdersDataSchema = void 0;
+const pre_order_conversion_skipped_schema_1 = require("./pre-order-conversion-skipped.schema");
+const zod_1 = require("zod");
+const pre_order_conversion_created_schema_1 = require("./pre-order-conversion-created.schema");
+const pre_order_conversion_failed_schema_1 = require("./pre-order-conversion-failed.schema");
+exports.GroupCreateOrdersFromPreOrdersDataSchema = zod_1.z.object({
+    created: pre_order_conversion_created_schema_1.PreOrderConversionCreatedSchema.array(),
+    skipped: pre_order_conversion_skipped_schema_1.PreOrderConversionSkippedSchema.array(),
+    failed: pre_order_conversion_failed_schema_1.PreOrderConversionFailedSchema.array(),
+});

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCreateOrdersFromPreOrdersRequestSchema = void 0;
+const zod_1 = require("zod");
+const matching_config_schema_1 = require("../pre-order-product/matching-config.schema");
+const pre_order_conversion_plan_entry_schema_1 = require("./pre-order-conversion-plan-entry.schema");
+exports.GroupCreateOrdersFromPreOrdersRequestSchema = zod_1.z.object({
+    preOrderUUIDs: zod_1.z.uuid().array(),
+    consignmentUUIDs: zod_1.z.uuid().array(),
+    matchingConfig: matching_config_schema_1.MatchingConfigSchema.optional().nullable(),
+    isProportionalAllocation: zod_1.z.coerce.boolean().optional(),
+    orderProductTag: zod_1.z.string().nullable().optional(),
+    confirmCloseRemainder: zod_1.z.boolean().optional(),
+    // Оформляется только подтверждённый сотрудником план: без него сервер подобрал бы товары заново, и в заказы
+    // ушли бы распределения и цены, которых сотрудник не видел.
+    plan: pre_order_conversion_plan_entry_schema_1.PreOrderConversionPlanEntrySchema.array(),
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCreateOrdersFromPreOrdersResponseSchema = void 0;
+const zod_1 = require("zod");
+const group_create_orders_from_pre_orders_data_schema_1 = require("./group-create-orders-from-pre-orders-data.schema");
+exports.GroupCreateOrdersFromPreOrdersResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: group_create_orders_from_pre_orders_data_schema_1.GroupCreateOrdersFromPreOrdersDataSchema,
+});

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

@@ -53,3 +53,42 @@ __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);
+__exportStar(require("./pre-order-conversion-plan-allocation.schema"), exports);
+__exportStar(require("./pre-order-conversion-failed-error.schema"), exports);
+__exportStar(require("./group-create-orders-from-pre-orders-data.schema"), exports);
+__exportStar(require("./group-create-orders-from-pre-orders-request.schema"), exports);
+__exportStar(require("./group-create-orders-from-pre-orders-response.schema"), exports);
+__exportStar(require("./pre-order-conversion-match.schema"), exports);
+__exportStar(require("./pre-order-conversion-mapping.schema"), exports);
+__exportStar(require("./pre-order-conversion-analysis.schema"), exports);
+__exportStar(require("./pre-order-conversion-error.schema"), exports);
+__exportStar(require("./analyze-create-orders-from-pre-orders-data.schema"), exports);
+__exportStar(require("./analyze-create-orders-from-pre-orders-request.schema"), exports);
+__exportStar(require("./analyze-create-orders-from-pre-orders-response.schema"), exports);
+__exportStar(require("./pre-order-conversion-plan-line.schema"), exports);
+__exportStar(require("./pre-order-conversion-plan-entry.schema"), exports);
+__exportStar(require("./pre-order-conversion-order.schema"), exports);
+__exportStar(require("./pre-order-conversion-created.schema"), exports);
+__exportStar(require("./pre-order-conversion-failed.schema"), exports);
+__exportStar(require("./pre-order-conversion-attributes.schema"), exports);
+__exportStar(require("./pre-order-conversion-difference.schema"), exports);
+__exportStar(require("./pre-order-conversion-remainder.schema"), exports);
+__exportStar(require("./pre-order-conversion-allocation.schema"), exports);
+__exportStar(require("./pre-order-conversion-summary-line.schema"), exports);
+__exportStar(require("./pre-order-conversion-summary.schema"), exports);
+__exportStar(require("./pre-order-conversion-match-description.schema"), exports);
+__exportStar(require("./pre-order-conversion-change.schema"), exports);
+__exportStar(require("./pre-order-conversion-skipped.schema"), exports);
+__exportStar(require("./pre-order-conversion-preview-plan-entry.schema"), exports);
+__exportStar(require("./pre-order-fulfillment-substitute.schema"), exports);
+__exportStar(require("./pre-order-fulfillment-stop-price.schema"), exports);
+__exportStar(require("./pre-order-fulfillment.schema"), exports);
+__exportStar(require("./pre-order-conversion-current-order.schema"), exports);
+__exportStar(require("./create-pre-order-webshop-response.schema"), exports);
+__exportStar(require("./update-pre-order-webshop-response.schema"), exports);
+__exportStar(require("./checkout-pre-order-webshop-request.schema"), exports);
+__exportStar(require("./checkout-pre-order-webshop-response.schema"), exports);
+__exportStar(require("./get-pre-order-by-collection-for-client-response.schema"), exports);
+__exportStar(require("./revert-pre-order-conversion-order.schema"), exports);
+__exportStar(require("./revert-pre-order-conversion-result.schema"), exports);
+__exportStar(require("./revert-pre-order-conversion-response.schema"), exports);

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionAllocationSchema = void 0;
+const pre_order_conversion_warning_enum_1 = require("../../enum/pre-order-conversion-warning.enum");
+const pre_order_conversion_match_kind_enum_1 = require("../../enum/pre-order-conversion-match-kind.enum");
+const zod_1 = require("zod");
+const money_schema_1 = require("../money.schema");
+const pre_order_conversion_difference_schema_1 = require("./pre-order-conversion-difference.schema");
+const pre_order_conversion_attributes_schema_1 = require("./pre-order-conversion-attributes.schema");
+exports.PreOrderConversionAllocationSchema = zod_1.z.object({
+    orderUUID: zod_1.z.uuid(),
+    orderId: zod_1.z.number().int(),
+    orderProductUUID: zod_1.z.uuid(),
+    productUUID: zod_1.z.uuid(),
+    quantity: zod_1.z.number().int().positive(),
+    orderProductQuantity: zod_1.z.number().int().positive(),
+    price: money_schema_1.MoneySchema,
+    multiplicityOptionUUID: zod_1.z.string().nullable(),
+    kind: zod_1.z.enum(pre_order_conversion_match_kind_enum_1.PreOrderConversionMatchKindEnum),
+    differences: pre_order_conversion_difference_schema_1.PreOrderConversionDifferenceSchema.array(),
+    warnings: zod_1.z.enum(pre_order_conversion_warning_enum_1.PreOrderConversionWarningEnum).array(),
+    product: pre_order_conversion_attributes_schema_1.PreOrderConversionAttributesSchema,
+});

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionAnalysisSchema = void 0;
+const zod_1 = require("zod");
+const pre_order_schema_1 = require("./pre-order.schema");
+const pre_order_conversion_mapping_schema_1 = require("./pre-order-conversion-mapping.schema");
+exports.PreOrderConversionAnalysisSchema = zod_1.z.object({
+    version: zod_1.z.string().optional(),
+    preOrder: pre_order_schema_1.PreOrderWithClientSchema,
+    mappings: zod_1.z.record(zod_1.z.string(), pre_order_conversion_mapping_schema_1.PreOrderConversionMappingSchema),
+    warnings: zod_1.z.array(zod_1.z.string()),
+});

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionAttributesSchema = void 0;
+const zod_1 = require("zod");
+exports.PreOrderConversionAttributesSchema = zod_1.z.object({
+    name: zod_1.z.string().nullable(),
+    size: zod_1.z.string().nullable(),
+    color: zod_1.z.string().nullable(),
+    grower: zod_1.z.string().nullable(),
+    categoryUUID: zod_1.z.string().nullable(),
+    categoryName: zod_1.z.string().nullable(),
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionChangeSchema = void 0;
+const zod_1 = require("zod");
+exports.PreOrderConversionChangeSchema = zod_1.z.object({
+    orderProductUUID: zod_1.z.uuid(),
+    isChangedAfterConversion: zod_1.z.boolean(),
+    isOrderAvailable: zod_1.z.boolean(),
+});

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionCreatedSchema = void 0;
+const pre_order_conversion_summary_schema_1 = require("./pre-order-conversion-summary.schema");
+const zod_1 = require("zod");
+const pre_order_conversion_order_schema_1 = require("./pre-order-conversion-order.schema");
+exports.PreOrderConversionCreatedSchema = zod_1.z.object({
+    preOrderUUID: zod_1.z.uuid(),
+    conversionSummary: pre_order_conversion_summary_schema_1.PreOrderConversionSummarySchema.nullable().optional(),
+    orders: pre_order_conversion_order_schema_1.PreOrderConversionOrderSchema.array(),
+});

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionCurrentOrderSchema = void 0;
+const zod_1 = require("zod");
+const order_status_enum_1 = require("../../enum/order-status.enum");
+exports.PreOrderConversionCurrentOrderSchema = zod_1.z.object({
+    uuid: zod_1.z.uuid(),
+    number: zod_1.z.number().int(),
+    status: zod_1.z.enum(order_status_enum_1.OrderStatusEnum).nullable(),
+    exists: zod_1.z.boolean(),
+});

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionDifferenceSchema = void 0;
+const pre_order_conversion_difference_field_enum_1 = require("../../enum/pre-order-conversion-difference-field.enum");
+const zod_1 = require("zod");
+exports.PreOrderConversionDifferenceSchema = zod_1.z.object({
+    field: zod_1.z.enum(pre_order_conversion_difference_field_enum_1.PreOrderConversionDifferenceFieldEnum),
+    requestedLabel: zod_1.z.string().nullable().optional(),
+    selectedLabel: zod_1.z.string().nullable().optional(),
+    requested: zod_1.z.string(),
+    selected: zod_1.z.string().nullable(),
+});

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionErrorSchema = void 0;
+const zod_1 = require("zod");
+exports.PreOrderConversionErrorSchema = zod_1.z.object({
+    preOrderUUID: zod_1.z.uuid(),
+    code: zod_1.z.string(),
+    message: zod_1.z.string(),
+});

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionFailedErrorSchema = void 0;
+const zod_1 = require("zod");
+exports.PreOrderConversionFailedErrorSchema = zod_1.z.object({
+    code: zod_1.z.string(),
+    message: zod_1.z.string(),
+});

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreOrderConversionFailedSchema = void 0;
+const zod_1 = require("zod");
+const pre_order_conversion_failed_error_schema_1 = require("./pre-order-conversion-failed-error.schema");
+exports.PreOrderConversionFailedSchema = zod_1.z.object({ preOrderUUID: zod_1.z.uuid(), error: pre_order_conversion_failed_error_schema_1.PreOrderConversionFailedErrorSchema });