@floristcloud/api-lib 1.2.1 → 1.2.4

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

@@ -0,0 +1,12 @@
+"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,
+});
+var GetPreOrderByPreOrderCollectionUuidContractCommand;
+(function (GetPreOrderByPreOrderCollectionUuidContractCommand) {
+    GetPreOrderByPreOrderCollectionUuidContractCommand.ResponseSchema = GetPreOrderResponseSchema;
+})(GetPreOrderByPreOrderCollectionUuidContractCommand || (exports.GetPreOrderByPreOrderCollectionUuidContractCommand = GetPreOrderByPreOrderCollectionUuidContractCommand = {}));

package/build/commands/pre-order/get-pre-order-list.query.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPreOrderListContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const enum_1 = require("../../enum");
+const GetPreOrderListRequestSchema = zod_1.z.object({
+    page: zod_1.z.string().transform(val => Number(val) || 1),
+    count: zod_1.z.coerce.number().optional().default(10),
+    searchQuery: zod_1.z.string().optional(),
+    clientUUID: zod_1.z.string().optional(),
+    preOrderCollectionUUID: zod_1.z.string().optional(),
+    status: zod_1.z.nativeEnum(enum_1.PreOrderStatusEnum).array().optional(),
+    createdAtFrom: zod_1.z.coerce.date().optional(),
+    createdAtTo: zod_1.z.coerce.date().optional(),
+    responsibleUserUUID: zod_1.z.string().optional(),
+    group: zod_1.z.string().optional(),
+});
+const GetPreOrderListResponseSchema = zod_1.z.object({
+    data: schemas_1.PreOrderListSchema,
+});
+var GetPreOrderListContractCommand;
+(function (GetPreOrderListContractCommand) {
+    GetPreOrderListContractCommand.RequestSchema = GetPreOrderListRequestSchema;
+    GetPreOrderListContractCommand.ResponseSchema = GetPreOrderListResponseSchema;
+})(GetPreOrderListContractCommand || (exports.GetPreOrderListContractCommand = GetPreOrderListContractCommand = {}));

package/build/commands/pre-order/get-pre-order.query.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPreOrderContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const GetPreOrdertResponseSchema = zod_1.z.object({
+    data: schemas_1.PreOrderExtendedSchema,
+});
+var GetPreOrderContractCommand;
+(function (GetPreOrderContractCommand) {
+    GetPreOrderContractCommand.ResponseSchema = GetPreOrdertResponseSchema;
+})(GetPreOrderContractCommand || (exports.GetPreOrderContractCommand = GetPreOrderContractCommand = {}));

package/build/commands/pre-order/get-standing-order-import-template.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetStandingOrderImportTemplateContractCommand = void 0;
+const zod_1 = require("zod");
+const GetStandingOrderImportTemplateResponseSchema = zod_1.z.object({
+    data: zod_1.z.object({
+        url: zod_1.z.string().url(),
+    }),
+});
+var GetStandingOrderImportTemplateContractCommand;
+(function (GetStandingOrderImportTemplateContractCommand) {
+    GetStandingOrderImportTemplateContractCommand.ResponseSchema = GetStandingOrderImportTemplateResponseSchema;
+})(GetStandingOrderImportTemplateContractCommand || (exports.GetStandingOrderImportTemplateContractCommand = GetStandingOrderImportTemplateContractCommand = {}));

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzeCopyPreOrdersContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const AnalyzeCopyPreOrdersRequestSchema = zod_1.z.object({
+    preOrderUUIDList: zod_1.z.array(zod_1.z.uuid()),
+    targetPreOrderCollectionUUID: zod_1.z.uuid(),
+    matchingConfig: schemas_1.MatchingConfigSchema.optional().nullable(),
+});
+const AnalyzeCopyPreOrdersResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        analyses: zod_1.z.array(schemas_1.CopyAnalysisSchema),
+        errorList: zod_1.z.array(zod_1.z.string()).optional(),
+    }),
+});
+var AnalyzeCopyPreOrdersContractCommand;
+(function (AnalyzeCopyPreOrdersContractCommand) {
+    AnalyzeCopyPreOrdersContractCommand.RequestSchema = AnalyzeCopyPreOrdersRequestSchema;
+    AnalyzeCopyPreOrdersContractCommand.ResponseSchema = AnalyzeCopyPreOrdersResponseSchema;
+    AnalyzeCopyPreOrdersContractCommand.AnalysisSchema = schemas_1.CopyAnalysisSchema;
+})(AnalyzeCopyPreOrdersContractCommand || (exports.AnalyzeCopyPreOrdersContractCommand = AnalyzeCopyPreOrdersContractCommand = {}));

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

@@ -0,0 +1,41 @@
+"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(),
+    }),
+});
+var AnalyzeCreateOrdersFromPreOrdersContractCommand;
+(function (AnalyzeCreateOrdersFromPreOrdersContractCommand) {
+    AnalyzeCreateOrdersFromPreOrdersContractCommand.RequestSchema = AnalyzeCreateOrdersFromPreOrdersRequestSchema;
+    AnalyzeCreateOrdersFromPreOrdersContractCommand.ResponseSchema = AnalyzeCreateOrdersFromPreOrdersResponseSchema;
+})(AnalyzeCreateOrdersFromPreOrdersContractCommand || (exports.AnalyzeCreateOrdersFromPreOrdersContractCommand = AnalyzeCreateOrdersFromPreOrdersContractCommand = {}));

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzeCreatePreOrdersFromStandingOrdersContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema = zod_1.z.object({
+    standingOrderUUIDs: zod_1.z.uuid().array(),
+    preOrderCollectionUUIDs: zod_1.z.uuid().array(),
+    matchingConfig: schemas_1.MatchingConfigSchema.optional().nullable(),
+});
+const AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        analyses: zod_1.z.array(zod_1.z.object({
+            standingOrder: schemas_1.PreOrderWithClientSchema,
+            mappings: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+                standingOrderProduct: schemas_1.PreOrderProductExtendedSchema,
+                matches: zod_1.z.array(zod_1.z.object({
+                    collectionItem: schemas_1.PreOrderCollectionItemSchema,
+                    quantity: zod_1.z.number(),
+                })),
+                remainingQuantity: zod_1.z.number(),
+            })),
+            warnings: zod_1.z.record(zod_1.z.string(), 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(),
+    }),
+});
+var AnalyzeCreatePreOrdersFromStandingOrdersContractCommand;
+(function (AnalyzeCreatePreOrdersFromStandingOrdersContractCommand) {
+    AnalyzeCreatePreOrdersFromStandingOrdersContractCommand.RequestSchema = AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema;
+    AnalyzeCreatePreOrdersFromStandingOrdersContractCommand.ResponseSchema = AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema;
+})(AnalyzeCreatePreOrdersFromStandingOrdersContractCommand || (exports.AnalyzeCreatePreOrdersFromStandingOrdersContractCommand = AnalyzeCreatePreOrdersFromStandingOrdersContractCommand = {}));

package/build/commands/pre-order/group/group-copy-pre-orders-to-collection.command.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupCopyPreOrdersToCollectionContractCommand = void 0;
+const zod_1 = require("zod");
+const pre_order_product_schema_1 = require("../../../schemas/pre-order-product/pre-order-product.schema");
+const GroupCopyPreOrdersToCollectionRequestSchema = zod_1.z.object({
+    preOrderUUIDList: zod_1.z.array(zod_1.z.uuid()),
+    targetPreOrderCollectionUUID: zod_1.z.uuid(),
+    matchingConfig: pre_order_product_schema_1.MatchingConfigSchema.optional().nullable(),
+});
+const GroupCopyPreOrdersToCollectionResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        created: zod_1.z.array(zod_1.z.object({
+            sourcePreOrder: zod_1.z.object({
+                uuid: zod_1.z.string(),
+                preOrderNum: zod_1.z.number(),
+                clientName: zod_1.z.string(),
+            }),
+            targetPreOrder: zod_1.z.object({
+                uuid: zod_1.z.string(),
+                preOrderNum: zod_1.z.number(),
+            }),
+            warnings: zod_1.z.array(zod_1.z.string()),
+        })),
+        failed: zod_1.z.array(zod_1.z.object({
+            sourcePreOrder: zod_1.z.object({
+                uuid: zod_1.z.string(),
+                preOrderNum: zod_1.z.number(),
+                clientName: zod_1.z.string(),
+            }),
+            error: zod_1.z.array(zod_1.z.string()),
+        })),
+    }),
+});
+var GroupCopyPreOrdersToCollectionContractCommand;
+(function (GroupCopyPreOrdersToCollectionContractCommand) {
+    GroupCopyPreOrdersToCollectionContractCommand.RequestSchema = GroupCopyPreOrdersToCollectionRequestSchema;
+    GroupCopyPreOrdersToCollectionContractCommand.ResponseSchema = GroupCopyPreOrdersToCollectionResponseSchema;
+})(GroupCopyPreOrdersToCollectionContractCommand || (exports.GroupCopyPreOrdersToCollectionContractCommand = GroupCopyPreOrdersToCollectionContractCommand = {}));

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

@@ -0,0 +1,39 @@
+"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(),
+});
+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(),
+    }),
+});
+var GroupCreateOrdersFromPreOrdersContractCommand;
+(function (GroupCreateOrdersFromPreOrdersContractCommand) {
+    GroupCreateOrdersFromPreOrdersContractCommand.RequestSchema = GroupCreateOrdersFromPreOrdersRequestSchema;
+    GroupCreateOrdersFromPreOrdersContractCommand.ResponseSchema = GroupCreateOrdersFromPreOrdersResponseSchema;
+})(GroupCreateOrdersFromPreOrdersContractCommand || (exports.GroupCreateOrdersFromPreOrdersContractCommand = GroupCreateOrdersFromPreOrdersContractCommand = {}));

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

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

package/build/commands/pre-order/group/group-delete-pre-order.command.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupDeletePreOrderContractCommand = void 0;
+const zod_1 = require("zod");
+const GroupDeletePreOrderRequestSchema = zod_1.z.object({
+    uuids: zod_1.z.array(zod_1.z.string()),
+});
+const GroupDeletePreOrderResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+    }),
+});
+var GroupDeletePreOrderContractCommand;
+(function (GroupDeletePreOrderContractCommand) {
+    GroupDeletePreOrderContractCommand.RequestSchema = GroupDeletePreOrderRequestSchema;
+    GroupDeletePreOrderContractCommand.ResponseSchema = GroupDeletePreOrderResponseSchema;
+})(GroupDeletePreOrderContractCommand || (exports.GroupDeletePreOrderContractCommand = GroupDeletePreOrderContractCommand = {}));

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupUpdatePreOrderContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const GroupUpdatePreOrderRequestSchema = zod_1.z.object({
+    uuids: zod_1.z.array(zod_1.z.string()),
+    data: schemas_1.UpdatePreOrderSchema,
+});
+const GroupUpdatePreOrderResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+    }),
+});
+var GroupUpdatePreOrderContractCommand;
+(function (GroupUpdatePreOrderContractCommand) {
+    GroupUpdatePreOrderContractCommand.RequestSchema = GroupUpdatePreOrderRequestSchema;
+    GroupUpdatePreOrderContractCommand.ResponseSchema = GroupUpdatePreOrderResponseSchema;
+})(GroupUpdatePreOrderContractCommand || (exports.GroupUpdatePreOrderContractCommand = GroupUpdatePreOrderContractCommand = {}));

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

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./group-create-pre-orders-from-standing-orders.command"), exports);
+__exportStar(require("./group-delete-pre-order.command"), exports);
+__exportStar(require("./group-update-pre-order.command"), exports);
+__exportStar(require("./analyze-create-pre-orders-from-standing-orders.command"), exports);
+__exportStar(require("./analyze-create-pre-orders-from-standing-orders.command"), exports);
+__exportStar(require("./analyze-create-orders-from-pre-orders.command"), exports);
+__exportStar(require("./group-create-orders-from-pre-orders.command"), exports);
+__exportStar(require("./analyze-copy-pre-orders.command"), exports);
+__exportStar(require("./group-copy-pre-orders-to-collection.command"), exports);
+__exportStar(require("./merge-pre-orders.command"), exports);

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergePreOrdersContractCommand = exports.MergePreOrdersGroupAnalysisResponseSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const MergePreOrdersRequestSchema = zod_1.z.object({
+    preOrderUUIDList: zod_1.z.array(zod_1.z.string().uuid()).min(2),
+});
+exports.MergePreOrdersGroupAnalysisResponseSchema = zod_1.z.object({
+    clientUUID: zod_1.z.string(),
+    branchUUID: zod_1.z.string().nullable(),
+    isPossible: zod_1.z.boolean(),
+    targetPreOrderUUID: zod_1.z.string().nullable(),
+    sourcePreOrdersUUIDs: zod_1.z.array(zod_1.z.string()),
+    errors: zod_1.z.array(schemas_1.ErrorMessageSchema),
+    warnings: zod_1.z.array(schemas_1.ErrorMessageSchema),
+    mergeInfo: zod_1.z
+        .object({
+        willMergeTags: zod_1.z.boolean(),
+        willMergeComments: zod_1.z.boolean(),
+        totalProducts: zod_1.z.number(),
+    })
+        .optional(),
+});
+const MergePreOrdersResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.array(exports.MergePreOrdersGroupAnalysisResponseSchema),
+});
+var MergePreOrdersContractCommand;
+(function (MergePreOrdersContractCommand) {
+    MergePreOrdersContractCommand.RequestSchema = MergePreOrdersRequestSchema;
+    MergePreOrdersContractCommand.ResponseSchema = MergePreOrdersResponseSchema;
+})(MergePreOrdersContractCommand || (exports.MergePreOrdersContractCommand = MergePreOrdersContractCommand = {}));

package/build/commands/pre-order/import-standing-order.command.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportStandingOrderContractCommand = void 0;
+const zod_1 = require("zod");
+const ImportRowErrorSchema = zod_1.z.object({
+    row: zod_1.z.number(),
+    column: zod_1.z.string(),
+    message: zod_1.z.string(),
+    code: zod_1.z.string(),
+    i18nKey: zod_1.z.string().optional(),
+    i18nParams: zod_1.z.record(zod_1.z.string(), zod_1.z.union([zod_1.z.string(), zod_1.z.number(), zod_1.z.null()])).optional(),
+});
+const ImportStandingOrderResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+        errors: zod_1.z.array(ImportRowErrorSchema),
+        warnings: zod_1.z.array(ImportRowErrorSchema),
+    }),
+});
+var ImportStandingOrderContractCommand;
+(function (ImportStandingOrderContractCommand) {
+    ImportStandingOrderContractCommand.ResponseSchema = ImportStandingOrderResponseSchema;
+})(ImportStandingOrderContractCommand || (exports.ImportStandingOrderContractCommand = ImportStandingOrderContractCommand = {}));

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

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./create-pre-order.command"), exports);
+__exportStar(require("./update-pre-order.command"), exports);
+__exportStar(require("./get-pre-order-list.query"), exports);
+__exportStar(require("./get-pre-order.query"), exports);
+__exportStar(require("./delete-pre-order.command"), exports);
+__exportStar(require("./group"), exports);
+__exportStar(require("./webshop"), exports);
+__exportStar(require("./webshop/update-pre-order-webshop.command"), exports);
+__exportStar(require("./get-pre-order-by-pre-order-collection-uuid.command"), exports);
+__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);

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePreOrderContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const UpdatePreOrderResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.PreOrderSchema,
+});
+var UpdatePreOrderContractCommand;
+(function (UpdatePreOrderContractCommand) {
+    UpdatePreOrderContractCommand.RequestSchema = schemas_1.UpdatePreOrderSchema;
+    UpdatePreOrderContractCommand.ResponseSchema = UpdatePreOrderResponseSchema;
+})(UpdatePreOrderContractCommand || (exports.UpdatePreOrderContractCommand = UpdatePreOrderContractCommand = {}));

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

@@ -0,0 +1,20 @@
+"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,
+});
+var CheckoutPreOrderWebshopContractCommand;
+(function (CheckoutPreOrderWebshopContractCommand) {
+    CheckoutPreOrderWebshopContractCommand.RequestSchema = CheckoutPreOrderWebshopRequestSchema;
+    CheckoutPreOrderWebshopContractCommand.ResponseSchema = CheckoutPreOrderWebshopResponseSchema;
+})(CheckoutPreOrderWebshopContractCommand || (exports.CheckoutPreOrderWebshopContractCommand = CheckoutPreOrderWebshopContractCommand = {}));

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatePreOrderWebshopContractCommand = void 0;
+const zod_1 = require("zod");
+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 || (exports.CreatePreOrderWebshopContractCommand = CreatePreOrderWebshopContractCommand = {}));

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeletePreOrderWebshopContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const DeletePreOrderWebshopResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.DeleteDataResponseSchema,
+});
+var DeletePreOrderWebshopContractCommand;
+(function (DeletePreOrderWebshopContractCommand) {
+    DeletePreOrderWebshopContractCommand.ResponseSchema = DeletePreOrderWebshopResponseSchema;
+})(DeletePreOrderWebshopContractCommand || (exports.DeletePreOrderWebshopContractCommand = DeletePreOrderWebshopContractCommand = {}));

package/build/commands/pre-order/webshop/get-pre-order-list-webshop.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPreOrderListWebshopContractCommand = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../../enum");
+const schemas_1 = require("../../../schemas");
+const GetPreOrderListWebshopRequestSchema = zod_1.z.object({
+    page: zod_1.z.coerce.number().optional().default(1),
+    count: zod_1.z.coerce.number().optional().default(10),
+    statuses: zod_1.z.array(zod_1.z.nativeEnum(enum_1.PreOrderStatusEnum)).optional(),
+});
+const GetPreOrderListResponseSchema = zod_1.z.object({
+    data: schemas_1.PreOrderListSchema,
+});
+var GetPreOrderListWebshopContractCommand;
+(function (GetPreOrderListWebshopContractCommand) {
+    GetPreOrderListWebshopContractCommand.RequestSchema = GetPreOrderListWebshopRequestSchema;
+    GetPreOrderListWebshopContractCommand.ResponseSchema = GetPreOrderListResponseSchema;
+})(GetPreOrderListWebshopContractCommand || (exports.GetPreOrderListWebshopContractCommand = GetPreOrderListWebshopContractCommand = {}));

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

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./update-pre-order-webshop.command"), exports);
+__exportStar(require("./create-pre-order-webshop.command"), exports);
+__exportStar(require("./get-pre-order-list-webshop.command"), exports);
+__exportStar(require("./delete-pre-order-webshop.command"), exports);
+__exportStar(require("./checkout-pre-order-webshop.command"), exports);

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdatePreOrderWebshopContractCommand = void 0;
+const zod_1 = require("zod");
+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 || (exports.UpdatePreOrderWebshopContractCommand = UpdatePreOrderWebshopContractCommand = {}));

package/build/commands/pre-order-collection/copy-pre-order-collection.command.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyPreOrderCollectionContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const CopyPreOrderCollectionResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.PreOrderCollectionSchema,
+});
+var CopyPreOrderCollectionContractCommand;
+(function (CopyPreOrderCollectionContractCommand) {
+    CopyPreOrderCollectionContractCommand.ResponseSchema = CopyPreOrderCollectionResponseSchema;
+})(CopyPreOrderCollectionContractCommand || (exports.CopyPreOrderCollectionContractCommand = CopyPreOrderCollectionContractCommand = {}));

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreatePreOrderCollectionContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const CreatePreOrderCollectionResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.PreOrderCollectionSchema,
+});
+var CreatePreOrderCollectionContractCommand;
+(function (CreatePreOrderCollectionContractCommand) {
+    CreatePreOrderCollectionContractCommand.RequestSchema = schemas_1.CreatePreOrderCollectionSchema;
+    CreatePreOrderCollectionContractCommand.ResponseSchema = CreatePreOrderCollectionResponseSchema;
+})(CreatePreOrderCollectionContractCommand || (exports.CreatePreOrderCollectionContractCommand = CreatePreOrderCollectionContractCommand = {}));

package/build/commands/pre-order-collection/delete-pre-order-collection.command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeletePreOrderCollectionContractCommand = void 0;
+const zod_1 = require("zod");
+const DeletePreOrderCollectionResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+    }),
+});
+var DeletePreOrderCollectionContractCommand;
+(function (DeletePreOrderCollectionContractCommand) {
+    DeletePreOrderCollectionContractCommand.ResponseSchema = DeletePreOrderCollectionResponseSchema;
+})(DeletePreOrderCollectionContractCommand || (exports.DeletePreOrderCollectionContractCommand = DeletePreOrderCollectionContractCommand = {}));

package/build/commands/pre-order-collection/get-pre-order-collection-all.query.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPreOrderCollectionAllContractQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const GetPreOrderCollectionAllResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.PreOrderCollectionSchema.array(),
+});
+var GetPreOrderCollectionAllContractQuery;
+(function (GetPreOrderCollectionAllContractQuery) {
+    GetPreOrderCollectionAllContractQuery.ResponseSchema = GetPreOrderCollectionAllResponseSchema;
+})(GetPreOrderCollectionAllContractQuery || (exports.GetPreOrderCollectionAllContractQuery = GetPreOrderCollectionAllContractQuery = {}));