@floristcloud/api-lib 1.2.1 → 1.2.3

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOrderListContractQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const date_helper_1 = require("../../helpers/date.helper");
+const enum_1 = require("../../enum");
+const GetOrderListRequestSchema = zod_1.z
+    .object({
+    page: zod_1.z.string().transform(val => Number(val) || 1),
+    count: zod_1.z.string().transform(val => Number(val) || 10),
+    startDate: zod_1.z.coerce.date().optional(),
+    endDate: zod_1.z.coerce.date().optional(),
+    isDelivery: zod_1.z.coerce.boolean().optional(),
+    isPaid: zod_1.z.coerce.boolean().optional(),
+    consignmentUUID: zod_1.z.string().optional(),
+    tag: zod_1.z.string().optional(),
+    clientUUID: zod_1.z.string().optional(),
+    searchQuery: zod_1.z.string().optional(),
+    consignmentDeliveryDate: zod_1.z.coerce.date().optional(),
+    byProductSearchQuery: zod_1.z.string().optional(),
+    statuses: zod_1.z.nativeEnum(enum_1.OrderStatusEnum).array().optional(),
+    type: zod_1.z.nativeEnum(enum_1.OrderTypeEnum).optional(),
+    city: zod_1.z.string().optional(),
+    responsibleUserUUID: zod_1.z.string().optional(),
+    group: zod_1.z.string().optional(),
+})
+    .refine(value => {
+    const { startDate, endDate } = value;
+    if (startDate && endDate) {
+        return (0, date_helper_1.dateRangeCheck)(startDate, endDate);
+    }
+    return true;
+}, {
+    message: 'End date must be greater than start date',
+    path: ['endDate', 'startDate'],
+});
+const GetOrderListResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        orderList: schemas_1.OrderExtendedSchema.array(),
+        total: zod_1.z.number(),
+    }),
+});
+var GetOrderListContractQuery;
+(function (GetOrderListContractQuery) {
+    GetOrderListContractQuery.RequestSchema = GetOrderListRequestSchema;
+    GetOrderListContractQuery.ResponseSchema = GetOrderListResponseSchema;
+})(GetOrderListContractQuery || (exports.GetOrderListContractQuery = GetOrderListContractQuery = {}));

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

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

package/build/commands/order/group/deletet-group-order.command.js

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

package/build/commands/order/group/get-group-order-invoice-info.query.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetGroupOrderInvoiceInfoContractQuery = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../../enum");
+const GetGroupOrderInvoiceInfoRequestSchema = zod_1.z.object({
+    ordersUUIDList: zod_1.z.array(zod_1.z.string().uuid()),
+});
+const GetGroupOrderInvoiceInfoResponseSchema = zod_1.z.object({
+    orders: zod_1.z.array(zod_1.z.object({
+        uuid: zod_1.z.string(),
+        availableChannels: zod_1.z.array(zod_1.z.nativeEnum(enum_1.NotificationChannelEnum)),
+        history: zod_1.z.array(zod_1.z.object({
+            uuid: zod_1.z.string(),
+            channel: zod_1.z.nativeEnum(enum_1.NotificationChannelEnum).nullable(),
+            status: zod_1.z.nativeEnum(enum_1.NotificationStatusEnum),
+            sentAt: zod_1.z.date(),
+            errorMessage: zod_1.z.string().nullable(),
+        })),
+        lastSentAt: zod_1.z.date().nullable(),
+    })),
+});
+var GetGroupOrderInvoiceInfoContractQuery;
+(function (GetGroupOrderInvoiceInfoContractQuery) {
+    GetGroupOrderInvoiceInfoContractQuery.RequestSchema = GetGroupOrderInvoiceInfoRequestSchema;
+    GetGroupOrderInvoiceInfoContractQuery.ResponseSchema = GetGroupOrderInvoiceInfoResponseSchema;
+})(GetGroupOrderInvoiceInfoContractQuery || (exports.GetGroupOrderInvoiceInfoContractQuery = GetGroupOrderInvoiceInfoContractQuery = {}));

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeOrdersContractCommand = exports.MergeOrdersGroupAnalysisResponseSchema = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const MergeOrdersRequestSchema = zod_1.z.object({
+    orderUUIDList: zod_1.z.array(zod_1.z.string().uuid()).min(2),
+});
+exports.MergeOrdersGroupAnalysisResponseSchema = zod_1.z.object({
+    clientUUID: zod_1.z.string(),
+    branchUUID: zod_1.z.string().nullable(),
+    isPossible: zod_1.z.boolean(),
+    targetOrderUUID: zod_1.z.string().nullable(),
+    sourceOrdersUUIDs: zod_1.z.array(zod_1.z.string()),
+    errors: zod_1.z.array(schemas_1.ErrorMessageSchema),
+    warnings: zod_1.z.array(schemas_1.ErrorMessageSchema),
+});
+const MergeOrdersAnalyzeResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.array(exports.MergeOrdersGroupAnalysisResponseSchema),
+});
+var MergeOrdersContractCommand;
+(function (MergeOrdersContractCommand) {
+    MergeOrdersContractCommand.RequestSchema = MergeOrdersRequestSchema;
+    MergeOrdersContractCommand.ResponseSchema = MergeOrdersAnalyzeResponseSchema;
+})(MergeOrdersContractCommand || (exports.MergeOrdersContractCommand = MergeOrdersContractCommand = {}));

package/build/commands/order/group/send-group-order-invoice.command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendGroupOrderInvoiceContractCommand = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../../enum");
+const SendGroupOrderInvoiceRequestSchema = zod_1.z.object({
+    orders: zod_1.z.array(zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+        channel: zod_1.z.nativeEnum(enum_1.NotificationChannelEnum).optional(),
+    })),
+});
+const SendGroupOrderInvoiceResponseSchema = zod_1.z.object({
+    processed: zod_1.z.number(),
+    success: zod_1.z.number(),
+    failed: zod_1.z.number(),
+});
+var SendGroupOrderInvoiceContractCommand;
+(function (SendGroupOrderInvoiceContractCommand) {
+    SendGroupOrderInvoiceContractCommand.RequestSchema = SendGroupOrderInvoiceRequestSchema;
+    SendGroupOrderInvoiceContractCommand.ResponseSchema = SendGroupOrderInvoiceResponseSchema;
+})(SendGroupOrderInvoiceContractCommand || (exports.SendGroupOrderInvoiceContractCommand = SendGroupOrderInvoiceContractCommand = {}));

package/build/commands/order/group/split-group-order.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SplitGroupOrderContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const SplitGroupOrderRequestSchema = zod_1.z.object({
+    orderUUIDList: zod_1.z.array(zod_1.z.string()),
+});
+const SplitGroupOrderResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.OrderSchema.array(),
+});
+var SplitGroupOrderContractCommand;
+(function (SplitGroupOrderContractCommand) {
+    SplitGroupOrderContractCommand.RequestSchema = SplitGroupOrderRequestSchema;
+    SplitGroupOrderContractCommand.ResponseSchema = SplitGroupOrderResponseSchema;
+})(SplitGroupOrderContractCommand || (exports.SplitGroupOrderContractCommand = SplitGroupOrderContractCommand = {}));

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateGroupOrderStatusContractCommand = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../../enum");
+const UpdateGroupOrderStatusRequestSchema = zod_1.z.object({
+    orderUUIDList: zod_1.z.array(zod_1.z.string()),
+    status: zod_1.z.nativeEnum(enum_1.OrderStatusEnum),
+});
+const UpdateGroupOrderStatusResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+    }),
+});
+var UpdateGroupOrderStatusContractCommand;
+(function (UpdateGroupOrderStatusContractCommand) {
+    UpdateGroupOrderStatusContractCommand.RequestSchema = UpdateGroupOrderStatusRequestSchema;
+    UpdateGroupOrderStatusContractCommand.ResponseSchema = UpdateGroupOrderStatusResponseSchema;
+})(UpdateGroupOrderStatusContractCommand || (exports.UpdateGroupOrderStatusContractCommand = UpdateGroupOrderStatusContractCommand = {}));

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateGroupOrderTagContractCommand = void 0;
+const zod_1 = require("zod");
+const UpdateGroupOrderTagRequestSchema = zod_1.z.object({
+    orderUUIDList: zod_1.z.array(zod_1.z.string()),
+    tag: zod_1.z.string().nullable(),
+});
+const UpdateGroupOrderTagResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+    }),
+});
+var UpdateGroupOrderTagContractCommand;
+(function (UpdateGroupOrderTagContractCommand) {
+    UpdateGroupOrderTagContractCommand.RequestSchema = UpdateGroupOrderTagRequestSchema;
+    UpdateGroupOrderTagContractCommand.ResponseSchema = UpdateGroupOrderTagResponseSchema;
+})(UpdateGroupOrderTagContractCommand || (exports.UpdateGroupOrderTagContractCommand = UpdateGroupOrderTagContractCommand = {}));

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateGroupOrderTypeContractCommand = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../../enum");
+const UpdateGroupOrderTypeRequestSchema = zod_1.z.object({
+    orderUUIDList: zod_1.z.array(zod_1.z.string()),
+    type: zod_1.z.nativeEnum(enum_1.OrderTypeEnum),
+});
+const UpdateGroupOrderTypeResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        success: zod_1.z.boolean(),
+    }),
+});
+var UpdateGroupOrderTypeContractCommand;
+(function (UpdateGroupOrderTypeContractCommand) {
+    UpdateGroupOrderTypeContractCommand.RequestSchema = UpdateGroupOrderTypeRequestSchema;
+    UpdateGroupOrderTypeContractCommand.ResponseSchema = UpdateGroupOrderTypeResponseSchema;
+})(UpdateGroupOrderTypeContractCommand || (exports.UpdateGroupOrderTypeContractCommand = UpdateGroupOrderTypeContractCommand = {}));

package/build/commands/order/index.js

@@ -0,0 +1,41 @@
+"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-order.command"), exports);
+__exportStar(require("./update-order.command"), exports);
+__exportStar(require("./delete-order.command"), exports);
+__exportStar(require("./get-order.query"), exports);
+__exportStar(require("./get-order-list.query"), exports);
+__exportStar(require("./copy-order.command"), exports);
+__exportStar(require("./export-order-invoice.command"), exports);
+__exportStar(require("./send-order-invoice.command"), exports);
+__exportStar(require("./apply-order-discount.command"), exports);
+__exportStar(require("./zeroing-receipt-delivery-order.command"), exports);
+// group
+__exportStar(require("./group/update-group-order-type.command"), exports);
+__exportStar(require("./group/update-group-order-tag.command"), exports);
+__exportStar(require("./group/deletet-group-order.command"), exports);
+__exportStar(require("./group/update-group-order-status.command"), exports);
+__exportStar(require("./group/split-group-order.command"), exports);
+__exportStar(require("./group/merge-orders.command"), exports);
+__exportStar(require("./group/get-group-order-invoice-info.query"), exports);
+__exportStar(require("./group/send-group-order-invoice.command"), exports);
+//webshop
+__exportStar(require("./webshop/get-order-for-client.query"), exports);
+__exportStar(require("./webshop/create-cart.command"), exports);
+__exportStar(require("./webshop/get-order-list-for-client.query"), exports);
+__exportStar(require("./webshop/update-cart.command"), exports);
+__exportStar(require("./webshop/get-order-sales-by-month.query"), exports);

package/build/commands/order/send-order-invoice.command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendOrderInvoiceContractCommand = void 0;
+const zod_1 = require("zod");
+const notification_channel_enum_1 = require("../../enum/notification-channel.enum");
+const SendOrderInvoiceRequestSchema = zod_1.z.object({
+    channel: zod_1.z
+        .enum([
+        notification_channel_enum_1.NotificationChannelEnum.WHATSAPP,
+        notification_channel_enum_1.NotificationChannelEnum.EMAIL,
+        notification_channel_enum_1.NotificationChannelEnum.MAX,
+        notification_channel_enum_1.NotificationChannelEnum.TELEGRAM_BOT,
+    ])
+        .optional(),
+});
+const SendOrderInvoiceResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        isSuccess: zod_1.z.boolean(),
+    }),
+});
+var SendOrderInvoiceContractCommand;
+(function (SendOrderInvoiceContractCommand) {
+    SendOrderInvoiceContractCommand.RequestSchema = SendOrderInvoiceRequestSchema;
+    SendOrderInvoiceContractCommand.ResponseSchema = SendOrderInvoiceResponseSchema;
+})(SendOrderInvoiceContractCommand || (exports.SendOrderInvoiceContractCommand = SendOrderInvoiceContractCommand = {}));

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateOrderContractCommand = void 0;
+const zod_1 = require("zod");
+const enum_1 = require("../../enum");
+const schemas_1 = require("../../schemas");
+const UpdateOrderRequestSchema = zod_1.z.object({
+    clientUUID: zod_1.z.uuid(),
+    branchUUID: zod_1.z.uuid().nullable(),
+    deliveryCost: zod_1.z.coerce.number(),
+    type: zod_1.z.nativeEnum(enum_1.OrderTypeEnum),
+    comment: zod_1.z.string().nullable(),
+    clientComment: zod_1.z.string().nullable(),
+    tag: zod_1.z.string().nullable(),
+    status: zod_1.z.nativeEnum(enum_1.OrderStatusEnum),
+    isPaid: zod_1.z.coerce.boolean(),
+    deliveryVat: zod_1.z.coerce.number().nullable(),
+    deliveryVatAmount: zod_1.z.coerce.number(),
+    completedAt: zod_1.z.coerce.date().nullable().optional(),
+    paymentDueAt: zod_1.z.coerce.date().nullable().optional(),
+});
+const UpdateOrderResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.OrderSchema.nullable(),
+});
+var UpdateOrderContractCommand;
+(function (UpdateOrderContractCommand) {
+    UpdateOrderContractCommand.RequestSchema = UpdateOrderRequestSchema;
+    UpdateOrderContractCommand.ResponseSchema = UpdateOrderResponseSchema;
+})(UpdateOrderContractCommand || (exports.UpdateOrderContractCommand = UpdateOrderContractCommand = {}));

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

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

package/build/commands/order/webshop/get-order-for-client.query.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOrderForClientContractQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const GetOrderForClientRequestSchema = zod_1.z.object({});
+const GetOrderForClientResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.OrderExtendedForClientSchema.nullable(),
+});
+var GetOrderForClientContractQuery;
+(function (GetOrderForClientContractQuery) {
+    GetOrderForClientContractQuery.RequestSchema = GetOrderForClientRequestSchema;
+    GetOrderForClientContractQuery.ResponseSchema = GetOrderForClientResponseSchema;
+})(GetOrderForClientContractQuery || (exports.GetOrderForClientContractQuery = GetOrderForClientContractQuery = {}));

package/build/commands/order/webshop/get-order-list-for-client.query.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOrderForClientListContractQuery = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const date_helper_1 = require("../../../helpers/date.helper");
+const order_status_enum_1 = require("../../../enum/order-status.enum");
+const enum_1 = require("../../../enum");
+const GetOrderForClientListRequestSchema = zod_1.z
+    .object({
+    page: zod_1.z.coerce.number().default(1),
+    count: zod_1.z.coerce.number().default(10),
+    startDate: zod_1.z.coerce
+        .date()
+        .optional()
+        .transform(val => (val ? (0, date_helper_1.setStartDay)(val) : val)),
+    endDate: zod_1.z.coerce
+        .date()
+        .optional()
+        .transform(val => (val ? (0, date_helper_1.setEndDay)(val) : val)),
+    isPaid: zod_1.z.coerce.boolean().optional(),
+    statuses: zod_1.z
+        .nativeEnum(order_status_enum_1.OrderStatusEnum)
+        .array()
+        .optional()
+        .transform(arr => (arr && arr.length === 0 ? enum_1.OrderWebshopAvailableStatusList : arr !== null && arr !== void 0 ? arr : enum_1.OrderWebshopAvailableStatusList))
+        .default(enum_1.OrderWebshopAvailableStatusList)
+        .refine(arr => arr.every(s => enum_1.OrderWebshopAvailableStatusList.includes(s)), {
+        message: 'Status is not allowed for webshop',
+    }),
+})
+    .refine(value => {
+    const { startDate, endDate } = value;
+    if (startDate && endDate) {
+        return (0, date_helper_1.dateRangeCheck)(startDate, endDate);
+    }
+    return true;
+}, {
+    message: 'End date must be greater than start date',
+    path: ['endDate', 'startDate'],
+});
+const GetOrderForClientListResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        orderList: schemas_1.OrderExtendedForClientSchema.array(),
+        total: zod_1.z.number(),
+    }),
+});
+var GetOrderForClientListContractQuery;
+(function (GetOrderForClientListContractQuery) {
+    GetOrderForClientListContractQuery.RequestSchema = GetOrderForClientListRequestSchema;
+    GetOrderForClientListContractQuery.ResponseSchema = GetOrderForClientListResponseSchema;
+})(GetOrderForClientListContractQuery || (exports.GetOrderForClientListContractQuery = GetOrderForClientListContractQuery = {}));

package/build/commands/order/webshop/get-order-sales-by-month.query.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOrderSalesByMonthContractQuery = void 0;
+const zod_1 = require("zod");
+const GetOrderSalesByMonthRequestSchema = zod_1.z.object({
+    month: zod_1.z.coerce.number().int().min(1).max(12),
+});
+const GetOrderSalesByMonthResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.number(),
+});
+var GetOrderSalesByMonthContractQuery;
+(function (GetOrderSalesByMonthContractQuery) {
+    GetOrderSalesByMonthContractQuery.RequestSchema = GetOrderSalesByMonthRequestSchema;
+    GetOrderSalesByMonthContractQuery.ResponseSchema = GetOrderSalesByMonthResponseSchema;
+})(GetOrderSalesByMonthContractQuery || (exports.GetOrderSalesByMonthContractQuery = GetOrderSalesByMonthContractQuery = {}));

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateCartContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../../schemas");
+const UpdateCartRequestSchema = zod_1.z.object({
+    clientComment: zod_1.z.string().nullable().optional().default(null),
+    branchUUID: zod_1.z.uuid().optional().nullable().default(null),
+    delivery: zod_1.z
+        .object({
+        deliveryDate: zod_1.z.coerce.date().optional().nullable().default(null),
+        address: zod_1.z.string().nullable().optional().default(null),
+        time: zod_1.z.string().nullable().optional().default(null),
+    })
+        .optional()
+        .nullable()
+        .default(null),
+});
+const UpdateCartResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.OrderForClientSchema,
+});
+var UpdateCartContractCommand;
+(function (UpdateCartContractCommand) {
+    UpdateCartContractCommand.RequestSchema = UpdateCartRequestSchema;
+    UpdateCartContractCommand.ResponseSchema = UpdateCartResponseSchema;
+})(UpdateCartContractCommand || (exports.UpdateCartContractCommand = UpdateCartContractCommand = {}));

package/build/commands/order/zeroing-receipt-delivery-order.command.js

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

package/build/commands/order-delivery/create-order-delivery.command.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateOrderDeliveryContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const CreateOrderDeliveryRequestSchema = zod_1.z.object({
+    deliveryDate: zod_1.z.coerce.date().nullable(),
+    city: zod_1.z.string().nullable(),
+    address: zod_1.z.string().nullable(),
+    time: zod_1.z.string().nullable(),
+    comment: zod_1.z.string().nullable(),
+});
+const CreateOrderDeliveryResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.OrderDeliverySchema.nullable(),
+});
+var CreateOrderDeliveryContractCommand;
+(function (CreateOrderDeliveryContractCommand) {
+    CreateOrderDeliveryContractCommand.RequestSchema = CreateOrderDeliveryRequestSchema;
+    CreateOrderDeliveryContractCommand.ResponseSchema = CreateOrderDeliveryResponseSchema;
+})(CreateOrderDeliveryContractCommand || (exports.CreateOrderDeliveryContractCommand = CreateOrderDeliveryContractCommand = {}));

package/build/commands/order-delivery/delete-order-delivery.command.js

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

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

@@ -0,0 +1,19 @@
+"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-order-delivery.command"), exports);
+__exportStar(require("./update-order-delivery.command"), exports);
+__exportStar(require("./delete-order-delivery.command"), exports);

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateOrderDeliveryContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const enum_1 = require("../../enum");
+const UpdateOrderDeliveryRequestSchema = zod_1.z
+    .object({
+    deliveryDate: zod_1.z.coerce.date().nullable(),
+    city: zod_1.z.string().nullable(),
+    address: zod_1.z.string().nullable(),
+    time: zod_1.z.string().nullable(),
+    comment: zod_1.z.string().nullable(),
+    orderDeliveryStatus: zod_1.z.nativeEnum(enum_1.OrderDeliveryStatusEnum),
+})
+    .partial();
+const UpdateOrderDeliveryResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.OrderDeliverySchema.nullable(),
+});
+var UpdateOrderDeliveryContractCommand;
+(function (UpdateOrderDeliveryContractCommand) {
+    UpdateOrderDeliveryContractCommand.RequestSchema = UpdateOrderDeliveryRequestSchema;
+    UpdateOrderDeliveryContractCommand.ResponseSchema = UpdateOrderDeliveryResponseSchema;
+})(UpdateOrderDeliveryContractCommand || (exports.UpdateOrderDeliveryContractCommand = UpdateOrderDeliveryContractCommand = {}));

package/build/commands/order-product/create-order-product.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateOrderProductContractCommand = void 0;
+const zod_1 = require("zod");
+const schemas_1 = require("../../schemas");
+const CreateOrderProductRequestSchema = zod_1.z.object({
+    quantity: zod_1.z.number(),
+    price: zod_1.z.number(),
+    comment: zod_1.z.string().nullable(),
+    tag: zod_1.z.string().nullable(),
+    isEditable: zod_1.z.coerce.boolean(),
+    multiplicityOptionUUID: zod_1.z.uuid().nullable().optional(),
+});
+const CreateOrderProductResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: schemas_1.OrderProductSchema.nullable(),
+});
+var CreateOrderProductContractCommand;
+(function (CreateOrderProductContractCommand) {
+    CreateOrderProductContractCommand.RequestSchema = CreateOrderProductRequestSchema;
+    CreateOrderProductContractCommand.ResponseSchema = CreateOrderProductResponseSchema;
+})(CreateOrderProductContractCommand || (exports.CreateOrderProductContractCommand = CreateOrderProductContractCommand = {}));

package/build/commands/order-product/delete-order-product.command.js

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

package/build/commands/order-product/get-order-product-list-all.query.js

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