@floristcloud/api-lib 1.2.180 → 1.2.182

package/commands/consignment/execute-consignment-product-update.command.ts

@@ -1,66 +1,11 @@
-import { z } from 'zod';
-import { ErrorMessageSchema } from '../../schemas/error-message.schema';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const OptionUpdateSchema = z.object({
-    title: z.string().nullable().optional(),
-    optionMultiplicity: z.number().nullable().optional(),
-    optionPrice: MoneySchema.nullable().optional(),
-    // Отсутствие поля — флаг не меняем; у создаваемой кратности берётся умолчание (скидки разрешены).
-    // Пустая ячейка в файле сюда не доезжает: разбор превращает её в отсутствие поля, а не в `false`.
-    isDiscountAllowed: z.boolean().optional(),
-});
-
-const ConsignmentProductPositionUpdateSchema = z.object({
-    name: z.string().nullable().optional(),
-    multiplicity: z.number().nullable().optional(),
-    quantity: z.number().nullable().optional(),
-    balance: z.number().nullable().optional(),
-    price: MoneySchema.nullable().optional(),
-    costPrice: MoneySchema.nullable().optional(),
-    invoicePrice: MoneySchema.nullable().optional(),
-    invoiceNumber: z.string().nullable().optional(),
-    multiplicityDescription: z.string().nullable().optional(),
-    vat: z.number().nullable().optional(),
-    article: z.string().nullable().optional(),
-    color: z.string().nullable().optional(),
-    vbn: z.string().nullable().optional(),
-    barcode: z.string().nullable().optional(),
-    size: z.string().nullable().optional(),
-    size2: z.string().nullable().optional(),
-    size3: z.string().nullable().optional(),
-    country: z.string().nullable().optional(),
-    description: z.string().nullable().optional(),
-    quality: z.string().nullable().optional(),
-    grower: z.string().nullable().optional(),
-    // `null` — слот кратности очищен, кратность надо удалить; отсутствие поля — слотом не управляем.
-    // Различие существенное: обновление по схеме импорта видит только те колонки, что она отображает,
-    // и не должно сносить кратность, которую просто не читает.
-    option1: OptionUpdateSchema.nullable().optional(),
-    option2: OptionUpdateSchema.nullable().optional(),
-});
-
-const UpdateBatchRequestSchema = z.object({
-    updates: z.record(z.string(), ConsignmentProductPositionUpdateSchema),
-});
-
-const UpdateBatchResponseSchema = z.object({
-    data: z.object({
-        success: z.boolean(),
-        successCount: z.number(),
-        failedCount: z.number(),
-        errors: z.array(
-            ErrorMessageSchema.extend({
-                uuid: z.string(),
-            }),
-        ),
-    }),
-});
+import type { z } from 'zod';
+import { ExecuteConsignmentProductUpdateRequestSchema } from '../../schemas/consignment/execute-consignment-product-update-request.schema';
+import { ExecuteConsignmentProductUpdateResponseSchema } from '../../schemas/consignment/execute-consignment-product-update-response.schema';
 
 export namespace ExecuteConsignmentProductUpdateContractCommand {
-    export const RequestSchema = UpdateBatchRequestSchema;
+    export const RequestSchema = ExecuteConsignmentProductUpdateRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
-    export const ResponseSchema = UpdateBatchResponseSchema;
+    export const ResponseSchema = ExecuteConsignmentProductUpdateResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/consignment/import-consignment.command.ts

@@ -1,38 +1,6 @@
-import { z } from 'zod';
-import { DataNotExistsSchema, ProductErrorTypeSchema } from '../../schemas';
-import { ConsignmentImportSchemaRelationEntityPropertyEnum, ConsignmentImportNameConventionEnum } from '../../enum';
-
-const ImportConsignmentRequestSchema = z.object({
-    isAggregate: z.coerce.boolean().optional().default(false),
-    isSeparateByGrower: z.coerce.boolean().optional().default(false),
-    isCutCategoryFromName: z.coerce.boolean().optional().default(false),
-    isFindImage: z.coerce.boolean().optional().default(false),
-    isRemoveSize: z.coerce.boolean().optional().default(false),
-    tradeMargin: z.coerce.number().optional().default(0),
-    coefficient: z.coerce.number().optional().default(0),
-    nameConvention: z.nativeEnum(ConsignmentImportNameConventionEnum).optional(),
-    constantData: z
-        .object({
-            [ConsignmentImportSchemaRelationEntityPropertyEnum.INVOICE_NUMBER]: z.string().nullable().optional(),
-            [ConsignmentImportSchemaRelationEntityPropertyEnum.GROWER]: z.string().nullable().optional(),
-            [ConsignmentImportSchemaRelationEntityPropertyEnum.COUNTRY]: z.string().nullable().optional(),
-        })
-        .optional(),
-});
-
-const ImportConsignmentResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        rows: z.number(),
-        warnings: z.array(
-            z.object({
-                row: z.number(),
-                errors: z.array(z.union([ProductErrorTypeSchema, DataNotExistsSchema])),
-            }),
-        ),
-    }),
-});
+import type { z } from 'zod';
+import { ImportConsignmentRequestSchema } from '../../schemas/consignment/import-consignment-request.schema';
+import { ImportConsignmentResponseSchema } from '../../schemas/consignment/import-consignment-response.schema';
 
 export namespace ImportConsignmentContractCommand {
     export const RequestSchema = ImportConsignmentRequestSchema;

package/commands/consignment/import-packing-consignment.command.ts

@@ -1,25 +1,6 @@
-import { z } from 'zod';
-import { DataNotExistsSchema, ProductErrorTypeSchema } from '../../schemas';
-
-const ImportPackingConsignmentRequestSchema = z.object({
-    isSeparateByGrower: z.coerce.boolean().optional().default(false),
-    isCutCategoryFromName: z.coerce.boolean().optional().default(false),
-    isRemoveSize: z.coerce.boolean().optional().default(false),
-});
-
-const ImportPackingConsignmentResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        rows: z.number(),
-        warnings: z.array(
-            z.object({
-                row: z.number(),
-                errors: z.array(z.union([ProductErrorTypeSchema, DataNotExistsSchema])),
-            }),
-        ),
-    }),
-});
+import type { z } from 'zod';
+import { ImportPackingConsignmentRequestSchema } from '../../schemas/consignment/import-packing-consignment-request.schema';
+import { ImportPackingConsignmentResponseSchema } from '../../schemas/consignment/import-packing-consignment-response.schema';
 
 export namespace ImportPackingConsignmentContractCommand {
     export const RequestSchema = ImportPackingConsignmentRequestSchema;

package/commands/index.ts

@@ -64,3 +64,4 @@ export { SessionRevokeAllContractCommand } from './session/session-revoke-all.co
 export { ValidateSessionS2SContractQuery } from './session/validate-session-s2s.query';
 export { ValidateWsTicketS2SContractQuery } from './session/validate-ws-ticket-s2s.query';
 export * from './transfer-document';
+export * from './measure-unit';

package/commands/integration/moysklad/execute-moysklad-import.command.ts

@@ -1,45 +1,6 @@
-import { z } from 'zod';
-import { SalesUnitEnum } from '../../../enum';
-import { MoneySchema } from '../../../schemas/money.schema';
-
-const ExecutableItemSchema = z.object({
-    externalSourceId: z.string(),
-    externalHref: z.string(),
-    name: z.string(),
-    article: z.string().nullable(),
-    barcode: z.string().nullable(),
-    size: z.string().nullable(),
-    color: z.string().nullable(),
-    country: z.string().nullable(),
-    grower: z.string().nullable(),
-    price: MoneySchema,
-    costPrice: MoneySchema,
-    balance: z.number(),
-    vat: z.number().nullable(),
-    salesUnit: z.nativeEnum(SalesUnitEnum),
-    status: z.enum(['new', 'known']),
-    internalUUID: z.string().nullable(),
-    resolvedCategoryUUID: z.string().nullable(),
-    resolvedImageUUID: z.string().nullable(),
-});
-
-const ExecuteMoyskladImportRequestSchema = z.object({
-    items: z.array(ExecutableItemSchema),
-    missingExternalIds: z.array(z.string()).default([]),
-    orphanedExternalIds: z.array(z.string()).default([]),
-});
-
-const ExecuteMoyskladImportResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        created: z.number(),
-        updated: z.number(),
-        archived: z.number(),
-        orphansCleaned: z.number(),
-        consignmentUUID: z.string(),
-    }),
-});
-
+import type { z } from 'zod';
+import { ExecuteMoyskladImportRequestSchema } from '../../../schemas/integration/moysklad/execute-moysklad-import-request.schema';
+import { ExecuteMoyskladImportResponseSchema } from '../../../schemas/integration/moysklad/execute-moysklad-import-response.schema';
 export namespace ExecuteMoyskladImportContractCommand {
     export const RequestSchema = ExecuteMoyskladImportRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;

package/commands/integration/moysklad/scan-moysklad-clients-import.query.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ClientLegalTypeEnum } from '../../../enum/client-legal-type.enum';
 import { ClientTypeEnum } from '../../../enum/client-type.enum';
+import { MoyskladImportItemStatusEnum } from '../../../enum/moysklad-import-item-status.enum';
 
 const ScannedClientItemSchema = z.object({
     externalSourceId: z.string(),
@@ -35,7 +36,7 @@ const ScannedClientItemSchema = z.object({
 
     isPhoneNormalized: z.boolean(),
 
-    status: z.enum(['new', 'known']),
+    status: z.nativeEnum(MoyskladImportItemStatusEnum),
     internalUUID: z.string().nullable(),
     suggestedMatch: z
         .object({

package/commands/integration/moysklad/scan-moysklad-import.query.ts

@@ -1,65 +1,5 @@
-import { z } from 'zod';
-import { SalesUnitEnum } from '../../../enum';
-import { MoneySchema } from '../../../schemas/money.schema';
-
-const ScannedItemSchema = z.object({
-    externalSourceId: z.string(),
-    externalHref: z.string(),
-    originalName: z.string(),
-    normalizedName: z.string(),
-    name: z.string(),
-    article: z.string().nullable(),
-    barcode: z.string().nullable(),
-    size: z.string().nullable(),
-    color: z.string().nullable(),
-    country: z.string().nullable(),
-    grower: z.string().nullable(),
-    price: MoneySchema,
-    costPrice: MoneySchema,
-    balance: z.number(),
-    categoryName: z.string().nullable(),
-    vat: z.number().nullable(),
-    salesUnit: z.nativeEnum(SalesUnitEnum),
-    status: z.enum(['new', 'known']),
-    internalUUID: z.string().nullable(),
-    resolvedCategoryUUID: z.string().nullable(),
-    resolvedCategoryName: z.string().nullable(),
-    resolvedImageUUID: z.string().nullable(),
-});
-
-const CategoryMatchSchema = z.object({
-    fcCategoryUUID: z.string(),
-    fcCategoryName: z.string(),
-    itemsCount: z.number(),
-});
-
-const ScanMoyskladImportResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        rawProductCount: z.number(),
-        expandedItemCount: z.number(),
-        knownItems: z.number(),
-        newItems: z.number(),
-        missingItemsCount: z.number(),
-        missingExternalIds: z.array(z.string()),
-        orphanedItemsCount: z.number(),
-        orphanedExternalIds: z.array(z.string()),
-        categories: z.object({
-            matched: z.array(CategoryMatchSchema),
-        }),
-        summary: z.object({
-            withCategory: z.number(),
-            withoutCategory: z.number(),
-            withColor: z.number(),
-            withCountry: z.number(),
-            withGrower: z.number(),
-            withSize: z.number(),
-            withImage: z.number(),
-        }),
-        items: z.array(ScannedItemSchema),
-    }),
-});
-
+import type { z } from 'zod';
+import { ScanMoyskladImportResponseSchema } from '../../../schemas/integration/moysklad/scan-moysklad-import-response.schema';
 export namespace ScanMoyskladImportContractQuery {
     export const ResponseSchema = ScanMoyskladImportResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;

package/commands/integration/one-c/index.ts

@@ -5,3 +5,5 @@ export * from './get-one-c-status.query';
 export * from './get-one-c-stock-conflict-list.query';
 export * from './get-one-c-stock-conflict-preview.query';
 export * from './resolve-one-c-stock-conflict.command';
+
+export * from './update-one-c-settings.command';

package/commands/integration/one-c/update-one-c-settings.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { UpdateOneCSettingsRequestSchema } from '../../../schemas/integration/one-c/update-one-c-settings-request.schema';
+import { UpdateOneCSettingsResponseSchema } from '../../../schemas/integration/one-c/update-one-c-settings-response.schema';
+
+export namespace UpdateOneCSettingsContractCommand {
+    export const RequestSchema = UpdateOneCSettingsRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = UpdateOneCSettingsResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/archive-measure-unit.command.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace ArchiveMeasureUnitContractCommand {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/create-measure-unit.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { CreateMeasureUnitRequestSchema } from '../../schemas/measure-unit/create-measure-unit-request.schema';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace CreateMeasureUnitContractCommand {
+    export const RequestSchema = CreateMeasureUnitRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/get-measure-unit-by-uuid.query.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace GetMeasureUnitByUUIDContractQuery {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/get-measure-unit-list.query.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { GetMeasureUnitListRequestSchema } from '../../schemas/measure-unit/get-measure-unit-list-request.schema';
+import { MeasureUnitListResponseSchema } from '../../schemas/measure-unit/measure-unit-list-response.schema';
+
+export namespace GetMeasureUnitListContractQuery {
+    export const RequestSchema = GetMeasureUnitListRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitListResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/index.ts

@@ -0,0 +1,8 @@
+export * from './create-measure-unit.command';
+export * from './update-measure-unit.command';
+export * from './set-default-measure-unit.command';
+export * from './reorder-measure-units.command';
+export * from './archive-measure-unit.command';
+export * from './unarchive-measure-unit.command';
+export * from './get-measure-unit-list.query';
+export * from './get-measure-unit-by-uuid.query';

package/commands/measure-unit/reorder-measure-units.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { ReorderMeasureUnitsRequestSchema } from '../../schemas/measure-unit/reorder-measure-units-request.schema';
+import { MeasureUnitListResponseSchema } from '../../schemas/measure-unit/measure-unit-list-response.schema';
+
+export namespace ReorderMeasureUnitsContractCommand {
+    export const RequestSchema = ReorderMeasureUnitsRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitListResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/set-default-measure-unit.command.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace SetDefaultMeasureUnitContractCommand {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/unarchive-measure-unit.command.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace UnarchiveMeasureUnitContractCommand {
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/measure-unit/update-measure-unit.command.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import { UpdateMeasureUnitRequestSchema } from '../../schemas/measure-unit/update-measure-unit-request.schema';
+import { MeasureUnitResponseSchema } from '../../schemas/measure-unit/measure-unit-response.schema';
+
+export namespace UpdateMeasureUnitContractCommand {
+    export const RequestSchema = UpdateMeasureUnitRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = MeasureUnitResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/order/group/order-vat-transition-analyze.command.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+import { OrderVatTransitionRequestSchema } from '../../../schemas/order/order-vat-transition-request.schema';
+import { OrderVatTransitionAnalyzeResponseSchema } from '../../../schemas/order/order-vat-transition-analyze-response.schema';
+
+export namespace OrderVatTransitionAnalyzeContractCommand {
+    export const RequestSchema = OrderVatTransitionRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = OrderVatTransitionAnalyzeResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/order/group/order-vat-transition-execute.command.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+import { OrderVatTransitionExecuteRequestSchema } from '../../../schemas/order/order-vat-transition-execute-request.schema';
+import { OrderVatTransitionExecuteResponseSchema } from '../../../schemas/order/order-vat-transition-execute-response.schema';
+
+export namespace OrderVatTransitionExecuteContractCommand {
+    export const RequestSchema = OrderVatTransitionExecuteRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = OrderVatTransitionExecuteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/order/index.ts

@@ -19,6 +19,8 @@ export * from './group/merge-orders.command';
 export * from './group/get-group-order-invoice-info.query';
 export * from './group/send-group-order-invoice.command';
 export * from './group/pin-group-order-planned-shipment-date.command';
+export * from './group/order-vat-transition-analyze.command';
+export * from './group/order-vat-transition-execute.command';
 //webshop
 export * from './webshop/get-order-for-client.query';
 export * from './webshop/create-cart.command';

package/commands/pre-order/import-standing-order.command.ts

@@ -1,22 +1,5 @@
-import { z } from 'zod';
-
-const ImportRowErrorSchema = z.object({
-    row: z.number(),
-    column: z.string(),
-    message: z.string(),
-    code: z.string(),
-    i18nKey: z.string().optional(),
-    i18nParams: z.record(z.string(), z.union([z.string(), z.number(), z.null()])).optional(),
-});
-
-const ImportStandingOrderResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        errors: z.array(ImportRowErrorSchema),
-        warnings: z.array(ImportRowErrorSchema),
-    }),
-});
+import type { z } from 'zod';
+import { ImportStandingOrderResponseSchema } from '../../schemas/pre-order/import-standing-order-response.schema';
 
 export namespace ImportStandingOrderContractCommand {
     export const ResponseSchema = ImportStandingOrderResponseSchema;

package/commands/pre-order-collection-item/import-pre-order-collection-item.command.ts

@@ -1,43 +1,6 @@
-import { z } from 'zod';
-import { PreOrderCollectionItemImportEntityPropertyEnum, PreOrderCollectionItemImportErrorsEnum } from '../../enum';
-
-const ImportPreOrderCollectionItemRequestSchema = z.object({});
-
-const PreOrderCollectionItemImportIssueParamsSchema = z.record(
-    z.string(),
-    z.union([z.string(), z.number(), z.null(), z.array(z.string())]),
-);
-
-const PreOrderCollectionItemImportIssueSchema = z.object({
-    path: z.nativeEnum(PreOrderCollectionItemImportEntityPropertyEnum).optional(),
-    type: z.nativeEnum(PreOrderCollectionItemImportErrorsEnum),
-    params: PreOrderCollectionItemImportIssueParamsSchema.optional(),
-});
-
-const PreOrderCollectionItemImportRowErrorSchema = z.object({
-    row: z.number(),
-    errors: z.array(PreOrderCollectionItemImportIssueSchema),
-});
-
-const PreOrderCollectionItemImportGlobalErrorSchema = z.object({
-    errors: z.array(PreOrderCollectionItemImportIssueSchema),
-});
-
-const PreOrderCollectionItemImportCreatedRowSchema = z.object({
-    row: z.number(),
-    uuid: z.string(),
-});
-
-const ImportPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        rows: z.number(),
-        created: z.array(PreOrderCollectionItemImportCreatedRowSchema),
-        errors: z.array(PreOrderCollectionItemImportRowErrorSchema),
-        warnings: z.array(PreOrderCollectionItemImportRowErrorSchema),
-        globalErrors: z.array(PreOrderCollectionItemImportGlobalErrorSchema).optional(),
-    }),
-});
+import type { z } from 'zod';
+import { ImportPreOrderCollectionItemRequestSchema } from '../../schemas/pre-order-collection-item/import-pre-order-collection-item-request.schema';
+import { ImportPreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-collection-item/import-pre-order-collection-item-response.schema';
 
 export namespace ImportPreOrderCollectionItemContractCommand {
     export const RequestSchema = ImportPreOrderCollectionItemRequestSchema;

package/commands/pre-order-collection-item/update-group-pre-order-collection-item.command.ts

@@ -1,17 +1,6 @@
-import { z } from 'zod';
-import { UpdatePreOrderCollectionItemSchema } from '../../schemas';
-
-const UpdateGroupPreOrderCollectionItemRequestSchema = z.object({
-    preOrderCollectionItemUUIDs: z.array(z.string()),
-    data: UpdatePreOrderCollectionItemSchema,
-});
-
-const UpdateGroupPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-    }),
-});
+import type { z } from 'zod';
+import { UpdateGroupPreOrderCollectionItemRequestSchema } from '../../schemas/pre-order-collection-item/update-group-pre-order-collection-item-request.schema';
+import { UpdateGroupPreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-collection-item/update-group-pre-order-collection-item-response.schema';
 
 export namespace UpdateGroupPreOrderCollectionItemContractCommand {
     export const RequestSchema = UpdateGroupPreOrderCollectionItemRequestSchema;

package/commands/product/create-product.command.ts

@@ -1,43 +1,6 @@
-import { z } from 'zod';
-import { ProductMarkEnum, SalesUnitEnum } from '../../enum';
-import { ProductExtendedForAdminSchema } from '../../schemas';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const CreateProductRequestSchema = z.object({
-    name: z.string(),
-    consignmentUUID: z.string(),
-    categoryUUID: z.string(),
-    balance: z.number(),
-    quantity: z.number(),
-    price: MoneySchema,
-    costPrice: MoneySchema,
-    multiplicity: z.number(),
-    isOpen: z.coerce.boolean(),
-
-    article: z.string().nullable(),
-    vbn: z.string().nullable(),
-    barcode: z.string().nullable(),
-    color: z.string().nullable(),
-    size: z.string().nullable(),
-    size2: z.string().nullable(),
-    size3: z.string().nullable(),
-    invoicePrice: MoneySchema.nullable(),
-    invoiceNumber: z.string().nullable(),
-    imageUUID: z.string().nullable(),
-    country: z.string().nullable(),
-    description: z.string().nullable(),
-    quality: z.string().nullable(),
-    grower: z.string().nullable(),
-    vat: z.number().nullable(),
-    multiplicityDescription: z.string().nullable(),
-    salesUnit: z.nativeEnum(SalesUnitEnum).optional().nullable(),
-    marks: z.array(z.nativeEnum(ProductMarkEnum)).optional(),
-});
-
-const CreateProductResponseSchema = z.object({
-    message: z.string().optional(),
-    data: ProductExtendedForAdminSchema,
-});
+import type { z } from 'zod';
+import { CreateProductRequestSchema } from '../../schemas/product/create-product-request.schema';
+import { CreateProductResponseSchema } from '../../schemas/product/create-product-response.schema';
 
 export namespace CreateProductContractCommand {
     export const RequestSchema = CreateProductRequestSchema;

package/commands/product/group/update-group-product-update-batch.command.ts

@@ -1,46 +1,6 @@
-import { z } from 'zod';
-import { SalesUnitEnum } from '../../../enum';
-import { ErrorMessageSchema } from '../../../schemas/error-message.schema';
-import { MoneySchema } from '../../../schemas/money.schema';
-
-const UpdateGroupProductUpdateBatchRequestSchema = z.object({
-    productUUIDList: z.array(z.string()),
-    data: z
-        .object({
-            name: z.string(),
-            categoryUUID: z.string(),
-            price: MoneySchema,
-            costPrice: MoneySchema,
-            color: z.string().nullable(),
-            size: z.string().nullable(),
-            multiplicity: z.coerce.number(),
-            size2: z.string().nullable(),
-            grower: z.string().nullable(),
-            country: z.string().nullable(),
-            invoicePrice: MoneySchema.nullable(),
-            invoiceNumber: z.string().nullable(),
-            imageUUID: z.string().nullable(),
-            multiplicityDescription: z.string().nullable(),
-            salesUnit: z.nativeEnum(SalesUnitEnum).nullable(),
-        })
-        .partial(),
-});
-
-const UpdateGroupProductUpdateBatchResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        successCount: z.number().optional(),
-        failedCount: z.number().optional(),
-        errors: z
-            .array(
-                ErrorMessageSchema.extend({
-                    productUUID: z.uuid(),
-                }),
-            )
-            .optional(),
-    }),
-});
+import type { z } from 'zod';
+import { UpdateGroupProductUpdateBatchRequestSchema } from '../../../schemas/product/group/update-group-product-update-batch-request.schema';
+import { UpdateGroupProductUpdateBatchResponseSchema } from '../../../schemas/product/group/update-group-product-update-batch-response.schema';
 
 export namespace UpdateGroupProductUpdateBatchContractCommand {
     export const RequestSchema = UpdateGroupProductUpdateBatchRequestSchema;