@floristcloud/api-lib 1.0.0

package/build/commands/product-in-package/create-product-in-package.command.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export declare namespace CreateProductInPackageContractCommand {
+    const RequestSchema: z.ZodObject<Omit<{
+        uuid: z.ZodString;
+        productUUID: z.ZodString;
+        packageUUID: z.ZodString;
+        quantityOfUnits: z.ZodNumber;
+        perUnits: z.ZodNumber;
+        quantity: z.ZodNumber;
+        status: z.ZodNativeEnum<typeof import("../..").ProductInPackageStatusEnum>;
+        deletedAt: z.ZodNullable<z.ZodDate>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+    }, "status" | "uuid" | "createdAt" | "updatedAt" | "deletedAt">, "strip", z.ZodTypeAny, {
+        quantity: number;
+        productUUID: string;
+        quantityOfUnits: number;
+        perUnits: number;
+        packageUUID: string;
+    }, {
+        quantity: number;
+        productUUID: string;
+        quantityOfUnits: number;
+        perUnits: number;
+        packageUUID: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        data: z.ZodObject<{
+            uuid: z.ZodString;
+            productUUID: z.ZodString;
+            packageUUID: z.ZodString;
+            quantityOfUnits: z.ZodNumber;
+            perUnits: z.ZodNumber;
+            quantity: z.ZodNumber;
+            status: z.ZodNativeEnum<typeof import("../..").ProductInPackageStatusEnum>;
+            deletedAt: z.ZodNullable<z.ZodDate>;
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+        }, "strip", z.ZodTypeAny, {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        }, {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        };
+        message?: string | undefined;
+    }, {
+        data: {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        };
+        message?: string | undefined;
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

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

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

package/build/commands/product-in-package/delete-from-orders-by-package.command.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare namespace DeleteFromOrdersByPackageContractCommand {
+    const RequestSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        data: z.ZodObject<{
+            success: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+        }, {
+            success: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            success: boolean;
+        };
+        message?: string | undefined;
+    }, {
+        data: {
+            success: boolean;
+        };
+        message?: string | undefined;
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/commands/product-in-package/delete-from-orders-by-package.command.js

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

package/build/commands/product-in-package/delete-product-in-package.command.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare namespace DeleteProductInPackageContractCommand {
+    const ResponseSchema: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        data: z.ZodObject<{
+            success: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+        }, {
+            success: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            success: boolean;
+        };
+        message?: string | undefined;
+    }, {
+        data: {
+            success: boolean;
+        };
+        message?: string | undefined;
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

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

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

package/build/commands/product-in-package/get-product-in-package-by-uuid.query.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+export declare namespace GetProductInPackageContractQuery {
+    const ResponseSchema: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        data: z.ZodObject<{
+            uuid: z.ZodString;
+            productUUID: z.ZodString;
+            packageUUID: z.ZodString;
+            quantityOfUnits: z.ZodNumber;
+            perUnits: z.ZodNumber;
+            quantity: z.ZodNumber;
+            status: z.ZodNativeEnum<typeof import("../..").ProductInPackageStatusEnum>;
+            deletedAt: z.ZodNullable<z.ZodDate>;
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+        }, "strip", z.ZodTypeAny, {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        }, {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        };
+        message?: string | undefined;
+    }, {
+        data: {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        };
+        message?: string | undefined;
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/commands/product-in-package/get-product-in-package-by-uuid.query.js

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

package/build/commands/product-in-package/index.d.ts

@@ -0,0 +1,5 @@
+export * from './create-product-in-package.command';
+export * from './update-product-in-package.command';
+export * from './get-product-in-package-by-uuid.query';
+export * from './delete-product-in-package.command';
+export * from './delete-from-orders-by-package.command';

package/build/commands/product-in-package/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("./create-product-in-package.command"), exports);
+__exportStar(require("./update-product-in-package.command"), exports);
+__exportStar(require("./get-product-in-package-by-uuid.query"), exports);
+__exportStar(require("./delete-product-in-package.command"), exports);
+__exportStar(require("./delete-from-orders-by-package.command"), exports);

package/build/commands/product-in-package/update-product-in-package.command.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+export declare namespace UpdateProductInPackageContractCommand {
+    const RequestSchema: z.ZodObject<{
+        status: z.ZodOptional<z.ZodNativeEnum<typeof import("../..").ProductInPackageStatusEnum>>;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        productUUID: z.ZodOptional<z.ZodString>;
+        quantityOfUnits: z.ZodOptional<z.ZodNumber>;
+        perUnits: z.ZodOptional<z.ZodNumber>;
+        packageUUID: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        status?: import("../..").ProductInPackageStatusEnum | undefined;
+        quantity?: number | undefined;
+        productUUID?: string | undefined;
+        quantityOfUnits?: number | undefined;
+        perUnits?: number | undefined;
+        packageUUID?: string | undefined;
+    }, {
+        status?: import("../..").ProductInPackageStatusEnum | undefined;
+        quantity?: number | undefined;
+        productUUID?: string | undefined;
+        quantityOfUnits?: number | undefined;
+        perUnits?: number | undefined;
+        packageUUID?: string | undefined;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        message: z.ZodOptional<z.ZodString>;
+        data: z.ZodObject<{
+            uuid: z.ZodString;
+            productUUID: z.ZodString;
+            packageUUID: z.ZodString;
+            quantityOfUnits: z.ZodNumber;
+            perUnits: z.ZodNumber;
+            quantity: z.ZodNumber;
+            status: z.ZodNativeEnum<typeof import("../..").ProductInPackageStatusEnum>;
+            deletedAt: z.ZodNullable<z.ZodDate>;
+            createdAt: z.ZodDate;
+            updatedAt: z.ZodDate;
+        }, "strip", z.ZodTypeAny, {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        }, {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        };
+        message?: string | undefined;
+    }, {
+        data: {
+            status: import("../..").ProductInPackageStatusEnum;
+            uuid: string;
+            createdAt: Date;
+            updatedAt: Date;
+            deletedAt: Date | null;
+            quantity: number;
+            productUUID: string;
+            quantityOfUnits: number;
+            perUnits: number;
+            packageUUID: string;
+        };
+        message?: string | undefined;
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/commands/product-in-package/update-product-in-package.command.js

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

package/build/commands/report/export-client-statement.query.d.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+export declare namespace ExportClientStatementContractQuery {
+    const RequestSchema: z.ZodEffects<z.ZodObject<{
+        startDate: z.ZodOptional<z.ZodDate>;
+        endDate: z.ZodOptional<z.ZodDate>;
+        clientUUID: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        clientUUID: string;
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+    }, {
+        clientUUID: string;
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+    }>, {
+        clientUUID: string;
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+    }, {
+        clientUUID: string;
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodArray<z.ZodObject<{
+            date: z.ZodDate;
+            type: z.ZodNativeEnum<typeof import("../..").ClientStatementTypeEnum>;
+            amount: z.ZodNumber;
+            description: z.ZodString;
+            documentNumber: z.ZodNullable<z.ZodString>;
+            transactionType: z.ZodNullable<z.ZodNativeEnum<typeof import("../..").TransactionTypeEnum>>;
+        }, "strip", z.ZodTypeAny, {
+            type: import("../..").ClientStatementTypeEnum;
+            date: Date;
+            description: string;
+            amount: number;
+            documentNumber: string | null;
+            transactionType: import("../..").TransactionTypeEnum | null;
+        }, {
+            type: import("../..").ClientStatementTypeEnum;
+            date: Date;
+            description: string;
+            amount: number;
+            documentNumber: string | null;
+            transactionType: import("../..").TransactionTypeEnum | null;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: {
+            type: import("../..").ClientStatementTypeEnum;
+            date: Date;
+            description: string;
+            amount: number;
+            documentNumber: string | null;
+            transactionType: import("../..").TransactionTypeEnum | null;
+        }[];
+    }, {
+        data: {
+            type: import("../..").ClientStatementTypeEnum;
+            date: Date;
+            description: string;
+            amount: number;
+            documentNumber: string | null;
+            transactionType: import("../..").TransactionTypeEnum | null;
+        }[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}

package/build/commands/report/export-client-statement.query.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportClientStatementContractQuery = void 0;
+const zod_1 = require("zod");
+const date_helper_1 = require("../../helpers/date.helper");
+const schemas_1 = require("../../schemas");
+const ExportClientStatementRequestSchema = zod_1.z
+    .object({
+    startDate: zod_1.z.coerce.date().optional(),
+    endDate: zod_1.z.coerce.date().optional(),
+    clientUUID: zod_1.z.string().uuid(),
+})
+    .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 ExportClientStatementResponseSchema = zod_1.z.object({
+    data: zod_1.z.array(schemas_1.ClientStatementItemSchema),
+});
+var ExportClientStatementContractQuery;
+(function (ExportClientStatementContractQuery) {
+    ExportClientStatementContractQuery.RequestSchema = ExportClientStatementRequestSchema;
+    ExportClientStatementContractQuery.ResponseSchema = ExportClientStatementResponseSchema;
+})(ExportClientStatementContractQuery || (exports.ExportClientStatementContractQuery = ExportClientStatementContractQuery = {}));

package/build/commands/report/export-inventory-movement.query.d.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { InventoryMovementTypeEnum } from '../../enum/inventory-movement-type.enum';
+export declare namespace ExportInventoryMovementContractQuery {
+    const RequestSchema: z.ZodEffects<z.ZodObject<{
+        startDate: z.ZodOptional<z.ZodDate>;
+        endDate: z.ZodOptional<z.ZodDate>;
+        categoryUUID: z.ZodOptional<z.ZodString>;
+        detailed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        detailed: boolean;
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+        categoryUUID?: string | undefined;
+    }, {
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+        categoryUUID?: string | undefined;
+        detailed?: boolean | undefined;
+    }>, {
+        detailed: boolean;
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+        categoryUUID?: string | undefined;
+    }, {
+        startDate?: Date | undefined;
+        endDate?: Date | undefined;
+        categoryUUID?: string | undefined;
+        detailed?: boolean | undefined;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        data: z.ZodArray<z.ZodUnion<[z.ZodObject<{
+            date: z.ZodString;
+            categoryUUID: z.ZodString;
+            categoryName: z.ZodString;
+            movementType: z.ZodNativeEnum<typeof InventoryMovementTypeEnum>;
+            quantity: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            date: string;
+            categoryUUID: string;
+            quantity: number;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        }, {
+            date: string;
+            categoryUUID: string;
+            quantity: number;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        }>, z.ZodObject<{
+            date: z.ZodString;
+            categoryUUID: z.ZodString;
+            categoryName: z.ZodString;
+            name: z.ZodString;
+            color: z.ZodNullable<z.ZodString>;
+            size: z.ZodNullable<z.ZodString>;
+            grower: z.ZodNullable<z.ZodString>;
+            movementType: z.ZodNativeEnum<typeof InventoryMovementTypeEnum>;
+            quantity: z.ZodNumber;
+            documentNumber: z.ZodNullable<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            date: string;
+            categoryUUID: string;
+            color: string | null;
+            grower: string | null;
+            quantity: number;
+            size: string | null;
+            documentNumber: string | null;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        }, {
+            name: string;
+            date: string;
+            categoryUUID: string;
+            color: string | null;
+            grower: string | null;
+            quantity: number;
+            size: string | null;
+            documentNumber: string | null;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        }>]>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        data: ({
+            date: string;
+            categoryUUID: string;
+            quantity: number;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        } | {
+            name: string;
+            date: string;
+            categoryUUID: string;
+            color: string | null;
+            grower: string | null;
+            quantity: number;
+            size: string | null;
+            documentNumber: string | null;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        })[];
+    }, {
+        data: ({
+            date: string;
+            categoryUUID: string;
+            quantity: number;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        } | {
+            name: string;
+            date: string;
+            categoryUUID: string;
+            color: string | null;
+            grower: string | null;
+            quantity: number;
+            size: string | null;
+            documentNumber: string | null;
+            categoryName: string;
+            movementType: InventoryMovementTypeEnum;
+        })[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}