@floristcloud/api-lib 1.2.175 → 1.2.177

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 });

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;