@floristcloud/api-lib 1.2.179 → 1.2.181

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/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;

package/commands/product/update-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 UpdateProductRequestSchema = 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 UpdateProductResponseSchema = z.object({
-    message: z.string().optional(),
-    data: ProductExtendedForAdminSchema,
-});
+import type { z } from 'zod';
+import { UpdateProductRequestSchema } from '../../schemas/product/update-product-request.schema';
+import { UpdateProductResponseSchema } from '../../schemas/product/update-product-response.schema';
 
 export namespace UpdateProductContractCommand {
     export const RequestSchema = UpdateProductRequestSchema;

package/commands/report/get-daily-orders-summary.query.ts

@@ -1,77 +1,6 @@
-import { z } from 'zod';
-import { OrderStatusEnum } from '../../enum/order-status.enum';
-import { ReportOrderDateBasisEnum } from '../../enum/report-order-date-basis.enum';
-import { dateRangeCheck, isStatementPeriodWithinLimit } from '../../helpers/date.helper';
-import { MoneySchema } from '../../schemas/money.schema';
-
-const GetDailyOrdersSummaryRequestSchema = z
-    .object({
-        startDate: z.coerce.date(),
-        endDate: z.coerce.date(),
-        // Ось периода — общая с отчётами продаж, чтобы сводка и отчёт за тот же период не разошлись
-        // в семантике. Дизъюнкции «любая из дат» здесь нет намеренно, см. ReportOrderDateBasisEnum.
-        //
-        // COMPLETED_AT сужает сводку до отгруженных заказов: даты отгрузки у остальных статусов
-        // просто нет. Поэтому на этой оси ordersCompleted равен ordersCreated, а фильтр по любому
-        // статусу кроме COMPLETED даёт нули — на фронте эти два фильтра совмещать не нужно.
-        dateBasis: z.nativeEnum(ReportOrderDateBasisEnum).default(ReportOrderDateBasisEnum.CREATED_AT),
-        // Необязательное сужение по статусу. Принимается и CSV (`?status=NEW,ACCEPTED`), и повтор
-        // параметра — как excludeClientUUID в ReportOrderFilterSchema.
-        //
-        // Служебные статусы здесь НЕ отсеиваются, хотя в сводку они и так не попадают: отсев на
-        // этом слое означал бы «фильтр пуст → фильтра нет», и `?status=TEMPLATE` вернул бы весь
-        // отчёт вместо нулей. Отбрасывает их билдер — там пустой результат остаётся пустым.
-        status: z
-            .union([z.string(), z.array(z.string())])
-            .transform(value => (Array.isArray(value) ? value : value.split(',')).map(item => item.trim()).filter(Boolean))
-            .pipe(z.array(z.nativeEnum(OrderStatusEnum)))
-            .optional(),
-    })
-    .refine(value => dateRangeCheck(value.startDate, value.endDate), {
-        message: 'validation.dateRange',
-        path: ['endDate', 'startDate'],
-    })
-    .refine(value => isStatementPeriodWithinLimit(value.startDate, value.endDate), {
-        message: 'validation.reportPeriodMax',
-        path: ['endDate', 'startDate'],
-    });
-
-const UnitsByMeasureSchema = z.object({
-    PIECE: z.number(),
-    PACK: z.number(),
-    BOX: z.number(),
-});
-
-const metricsShape = {
-    ordersCreated: z.number(),
-    ordersCompleted: z.number(),
-    totalSum: MoneySchema,
-    // Часть totalSum по заказам со статусом COMPLETED. На оси COMPLETED_AT равна totalSum:
-    // там весь срез и так отгружен.
-    completedSum: MoneySchema,
-    unitsByMeasure: UnitsByMeasureSchema,
-};
-
-const DailyOrdersSummaryTotalsSchema = z.object({ ...metricsShape });
-
-const DailyOrdersSummaryByDayItemSchema = z.object({
-    date: z.string(),
-    ...metricsShape,
-});
-
-const DailyOrdersSummaryByResponsibleItemSchema = z.object({
-    responsibleUserUUID: z.string().nullable(),
-    responsibleUserName: z.string().nullable(),
-    ...metricsShape,
-});
-
-const GetDailyOrdersSummaryResponseSchema = z.object({
-    data: z.object({
-        totals: DailyOrdersSummaryTotalsSchema,
-        byDay: z.array(DailyOrdersSummaryByDayItemSchema),
-        byResponsible: z.array(DailyOrdersSummaryByResponsibleItemSchema),
-    }),
-});
+import type { z } from 'zod';
+import { GetDailyOrdersSummaryRequestSchema } from '../../schemas/report/get-daily-orders-summary-request.schema';
+import { GetDailyOrdersSummaryResponseSchema } from '../../schemas/report/get-daily-orders-summary-response.schema';
 
 export namespace GetDailyOrdersSummaryContractQuery {
     export const RequestSchema = GetDailyOrdersSummaryRequestSchema;

package/commands/settings/get-settings-private.query.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { SettingsPrivateResponseSchema } from '../../schemas/settings/settings-private-response.schema';
+
+export namespace GetSettingsPrivateContractQuery {
+    export const ResponseSchema = SettingsPrivateResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}