@floristcloud/api-lib 1.2.176 → 1.2.179

package/commands/order/index.ts

@@ -25,3 +25,5 @@ export * from './webshop/create-cart.command';
 export * from './webshop/get-order-list-for-client.query';
 export * from './webshop/update-cart.command';
 export * from './webshop/get-order-sales-by-month.query';
+
+export * from './get-order-delivery-pricing.query';

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/delivery-pricing-in-transit-mode.enum.ts

@@ -0,0 +1,4 @@
+export enum DeliveryPricingInTransitModeEnum {
+    FREE = 'FREE',
+    SAME_RULES = 'SAME_RULES',
+}

package/enum/delivery-pricing-rule-scope.enum.ts

@@ -0,0 +1,5 @@
+export enum DeliveryPricingRuleScopeEnum {
+    DEFAULT = 'DEFAULT',
+    CITY = 'CITY',
+    GROUP = 'GROUP',
+}

package/enum/index.ts

@@ -152,3 +152,13 @@ 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';
+
+export * from './delivery-pricing-rule-scope.enum';
+export * from './delivery-pricing-in-transit-mode.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/helpers/canonical-money-key.helper.ts

@@ -0,0 +1,5 @@
+/** Input has already passed MoneySchema. Compare decimal strings without floating point arithmetic. */
+export const canonicalMoneyKey = (value: string): string => {
+    const [integer, fraction = ''] = value.split('.');
+    return `${integer.replace(/^0+(?=\d)/, '')}.${(fraction + '00').slice(0, 2)}`;
+};

package/helpers/normalize-delivery-pricing-value.helper.ts

@@ -0,0 +1 @@
+export const normalizeDeliveryPricingValue = (value: string): string => value.trim().toLowerCase();

package/helpers/validate-unique-delivery-pricing-rules.helper.ts

@@ -0,0 +1,18 @@
+import type { RefinementCtx } from 'zod';
+import { DeliveryPricingRuleScopeEnum } from '../enum/delivery-pricing-rule-scope.enum';
+import { normalizeDeliveryPricingValue } from './normalize-delivery-pricing-value.helper';
+
+export function validateUniqueDeliveryPricingRules(
+    rules: { scope: DeliveryPricingRuleScopeEnum; value: string | null }[],
+    ctx: RefinementCtx,
+): void {
+    const seen = new Set<string>();
+    rules.forEach((rule, index) => {
+        const value = normalizeDeliveryPricingValue(rule.value ?? '');
+        const key = `${rule.scope}:${value}`;
+        if (seen.has(key)) {
+            ctx.addIssue({ code: 'custom', path: [index, 'value'], message: 'Duplicate delivery pricing rule' });
+        }
+        seen.add(key);
+    });
+}

package/helpers/validate-unique-delivery-pricing-thresholds.helper.ts

@@ -0,0 +1,13 @@
+import type { RefinementCtx } from 'zod';
+import { canonicalMoneyKey } from './canonical-money-key.helper';
+
+export function validateUniqueDeliveryPricingThresholds(tiers: { minSubtotal: string }[], ctx: RefinementCtx): void {
+    const thresholds = new Set<string>();
+    tiers.forEach((tier, index) => {
+        const key = canonicalMoneyKey(tier.minSubtotal);
+        if (thresholds.has(key)) {
+            ctx.addIssue({ code: 'custom', path: [index, 'minSubtotal'], message: 'Duplicate delivery pricing threshold' });
+        }
+        thresholds.add(key);
+    });
+}

package/package.json

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

package/schemas/index.ts

@@ -107,6 +107,10 @@ export * from './report/user-activity-summary-row.schema';
 export * from './report/user-activity-timeline-row.schema';
 export * from './service/service.schema';
 export * from './settings/settings.schema';
+export * from './settings/city-delivery-pricing-rule.schema';
+export * from './settings/default-delivery-pricing-rule.schema';
+export * from './settings/group-delivery-pricing-rule.schema';
+export * from './settings/delivery-pricing-tiers.schema';
 export * from './transaction';
 export * from './transaction/transaction-list.schema';
 export * from './transaction/transaction.schema';

package/schemas/order/delivery-pricing.schema.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+import { DeliveryPricingTierSchema } from '../settings/delivery-pricing-tier.schema';
+import { DeliveryPricingInTransitModeEnum } from '../../enum/delivery-pricing-in-transit-mode.enum';
+
+export const DeliveryPricingSchema = z.object({
+    cost: MoneySchema,
+    inStockSubtotal: MoneySchema,
+    tiers: z.array(DeliveryPricingTierSchema),
+    inTransitMode: z.nativeEnum(DeliveryPricingInTransitModeEnum),
+});

package/schemas/order/get-order-delivery-pricing-request.schema.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+
+export const GetOrderDeliveryPricingRequestSchema = z.object({ orderUUID: z.string().uuid() });

package/schemas/order/get-order-delivery-pricing-response.schema.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { DeliveryPricingSchema } from './delivery-pricing.schema';
+
+export const GetOrderDeliveryPricingResponseSchema = z.object({
+    message: z.string().optional(),
+    data: DeliveryPricingSchema.nullable(),
+});

package/schemas/order/index.ts

@@ -12,3 +12,7 @@ export * from './order.schema';
 export * from './update-cart-delivery-request.schema';
 export * from './update-cart-request.schema';
 export * from './update-cart-response.schema';
+
+export * from './delivery-pricing.schema';
+export * from './get-order-delivery-pricing-request.schema';
+export * from './get-order-delivery-pricing-response.schema';

package/schemas/order/order-extended-for-client.schema.ts

@@ -1,3 +1,4 @@
+import { DeliveryPricingSchema } from './delivery-pricing.schema';
 import { z } from 'zod';
 import { OrderForClientSchema } from './order-for-client.schema';
 import { ClientForClientSchema } from '../client/client-for-client.schema';
@@ -11,7 +12,8 @@ export const OrderExtendedForClientSchema = OrderForClientSchema.extend({
     delivery: OrderDeliverySchema.nullable(),
     writeOffSum: MoneySchema,
     consignmentDeliveryDates: z.union([z.date(), z.literal('in-stock')]).array(),
-    // Server-computed delivery cost for the current subtotal when the tier rule is on (null when off).
-    // Convenience preview for the cart page; the storefront still recomputes locally on the delivery/pickup toggle.
+    // Server quote for the current cart; transit products do not contribute to the stock threshold.
+    deliveryPricing: DeliveryPricingSchema.nullable(),
+    /** @deprecated One-release compatibility alias for deliveryPricing.cost. */
     deliveryCostPreview: MoneySchema.nullable(),
 });

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

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

@@ -0,0 +1,10 @@
+import { PreOrderConversionSkippedSchema } from './pre-order-conversion-skipped.schema';
+import { z } from 'zod';
+import { PreOrderConversionCreatedSchema } from './pre-order-conversion-created.schema';
+import { PreOrderConversionFailedSchema } from './pre-order-conversion-failed.schema';
+
+export const GroupCreateOrdersFromPreOrdersDataSchema = z.object({
+    created: PreOrderConversionCreatedSchema.array(),
+    skipped: PreOrderConversionSkippedSchema.array(),
+    failed: PreOrderConversionFailedSchema.array(),
+});

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

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { MatchingConfigSchema } from '../pre-order-product/matching-config.schema';
+import { PreOrderConversionPlanEntrySchema } from './pre-order-conversion-plan-entry.schema';
+
+export 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(),
+    confirmCloseRemainder: z.boolean().optional(),
+    // Оформляется только подтверждённый сотрудником план: без него сервер подобрал бы товары заново, и в заказы
+    // ушли бы распределения и цены, которых сотрудник не видел.
+    plan: PreOrderConversionPlanEntrySchema.array(),
+});

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

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

package/schemas/pre-order/index.ts

@@ -37,3 +37,46 @@ export * from './standing-order-conversion-plan-line.schema';
 export * from './standing-order-conversion-result.schema';
 export * from './standing-order-conversion-target-pre-order.schema';
 export * from './standing-order-conversion-target.schema';
+export * from './pre-order-conversion-plan-allocation.schema';
+export * from './pre-order-conversion-failed-error.schema';
+export * from './group-create-orders-from-pre-orders-data.schema';
+export * from './group-create-orders-from-pre-orders-request.schema';
+export * from './group-create-orders-from-pre-orders-response.schema';
+export * from './pre-order-conversion-match.schema';
+export * from './pre-order-conversion-mapping.schema';
+export * from './pre-order-conversion-analysis.schema';
+export * from './pre-order-conversion-error.schema';
+export * from './analyze-create-orders-from-pre-orders-data.schema';
+export * from './analyze-create-orders-from-pre-orders-request.schema';
+export * from './analyze-create-orders-from-pre-orders-response.schema';
+export * from './pre-order-conversion-plan-line.schema';
+export * from './pre-order-conversion-plan-entry.schema';
+export * from './pre-order-conversion-order.schema';
+export * from './pre-order-conversion-created.schema';
+export * from './pre-order-conversion-failed.schema';
+export * from './pre-order-conversion-attributes.schema';
+export * from './pre-order-conversion-difference.schema';
+export * from './pre-order-conversion-remainder.schema';
+export * from './pre-order-conversion-allocation.schema';
+export * from './pre-order-conversion-summary-line.schema';
+export * from './pre-order-conversion-summary.schema';
+export * from './pre-order-conversion-match-description.schema';
+export * from './pre-order-conversion-change.schema';
+export * from './pre-order-conversion-skipped.schema';
+export * from './pre-order-conversion-preview-plan-entry.schema';
+
+export * from './pre-order-fulfillment-substitute.schema';
+
+export * from './pre-order-fulfillment-stop-price.schema';
+
+export * from './pre-order-fulfillment.schema';
+
+export * from './pre-order-conversion-current-order.schema';
+export * from './create-pre-order-webshop-response.schema';
+export * from './update-pre-order-webshop-response.schema';
+export * from './checkout-pre-order-webshop-request.schema';
+export * from './checkout-pre-order-webshop-response.schema';
+export * from './get-pre-order-by-collection-for-client-response.schema';
+export * from './revert-pre-order-conversion-order.schema';
+export * from './revert-pre-order-conversion-result.schema';
+export * from './revert-pre-order-conversion-response.schema';

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

@@ -0,0 +1,21 @@
+import { PreOrderConversionWarningEnum } from '../../enum/pre-order-conversion-warning.enum';
+import { PreOrderConversionMatchKindEnum } from '../../enum/pre-order-conversion-match-kind.enum';
+import { z } from 'zod';
+import { MoneySchema } from '../money.schema';
+import { PreOrderConversionDifferenceSchema } from './pre-order-conversion-difference.schema';
+import { PreOrderConversionAttributesSchema } from './pre-order-conversion-attributes.schema';
+
+export const PreOrderConversionAllocationSchema = z.object({
+    orderUUID: z.uuid(),
+    orderId: z.number().int(),
+    orderProductUUID: z.uuid(),
+    productUUID: z.uuid(),
+    quantity: z.number().int().positive(),
+    orderProductQuantity: z.number().int().positive(),
+    price: MoneySchema,
+    multiplicityOptionUUID: z.string().nullable(),
+    kind: z.enum(PreOrderConversionMatchKindEnum),
+    differences: PreOrderConversionDifferenceSchema.array(),
+    warnings: z.enum(PreOrderConversionWarningEnum).array(),
+    product: PreOrderConversionAttributesSchema,
+});

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { PreOrderWithClientSchema } from './pre-order.schema';
+import { PreOrderConversionMappingSchema } from './pre-order-conversion-mapping.schema';
+
+export const PreOrderConversionAnalysisSchema = z.object({
+    version: z.string().optional(),
+    preOrder: PreOrderWithClientSchema,
+    mappings: z.record(z.string(), PreOrderConversionMappingSchema),
+    warnings: z.array(z.string()),
+});

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

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const PreOrderConversionAttributesSchema = z.object({
+    name: z.string().nullable(),
+    size: z.string().nullable(),
+    color: z.string().nullable(),
+    grower: z.string().nullable(),
+    categoryUUID: z.string().nullable(),
+    categoryName: z.string().nullable(),
+});

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

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+
+export const PreOrderConversionChangeSchema = z.object({
+    orderProductUUID: z.uuid(),
+    isChangedAfterConversion: z.boolean(),
+    isOrderAvailable: z.boolean(),
+});