@floristcloud/api-lib 1.2.160 → 1.2.162

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

@@ -1,55 +1,10 @@
 import { z } from 'zod';
-import {
-    ErrorMessageSchema,
-    MatchingConfigSchema,
-    PreOrderCollectionItemSchema,
-    PreOrderProductExtendedSchema,
-    PreOrderWithClientSchema,
-} from '../../../schemas';
-
-const AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema = z.object({
-    standingOrderUUIDs: z.uuid().array(),
-    preOrderCollectionUUIDs: z.uuid().array(),
-    matchingConfig: MatchingConfigSchema.optional().nullable(),
-});
-
-const AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        analyses: z.array(
-            z.object({
-                standingOrder: PreOrderWithClientSchema,
-                mappings: z.record(
-                    z.string(),
-                    z.object({
-                        standingOrderProduct: PreOrderProductExtendedSchema,
-                        matches: z.array(
-                            z.object({
-                                collectionItem: PreOrderCollectionItemSchema,
-                                quantity: z.number(),
-                            }),
-                        ),
-                        remainingQuantity: z.number(),
-                    }),
-                ),
-                warnings: z.record(z.string(), z.array(ErrorMessageSchema)),
-            }),
-        ),
-        errorList: z
-            .array(
-                z.object({
-                    code: z.string(),
-                    message: z.string(),
-                }),
-            )
-            .optional(),
-    }),
-});
+import { AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema } from '../../../schemas/pre-order/analyze-create-pre-orders-from-standing-orders-request.schema';
+import { AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema } from '../../../schemas/pre-order/analyze-create-pre-orders-from-standing-orders-response.schema';
 
 export namespace AnalyzeCreatePreOrdersFromStandingOrdersContractCommand {
     export const RequestSchema = AnalyzeCreatePreOrdersFromStandingOrdersRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = AnalyzeCreatePreOrdersFromStandingOrdersResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

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

@@ -1,47 +1,10 @@
 import { z } from 'zod';
-import { MatchingConfigSchema } from '../../../schemas/pre-order-product/pre-order-product.schema';
-import { ErrorMessageSchema } from '../../../schemas/error-message.schema';
-
-const GroupCopyPreOrdersToCollectionRequestSchema = z.object({
-    preOrderUUIDList: z.array(z.uuid()),
-    targetPreOrderCollectionUUID: z.uuid(),
-    matchingConfig: MatchingConfigSchema.optional().nullable(),
-});
-
-const GroupCopyPreOrdersToCollectionResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        created: z.array(
-            z.object({
-                sourcePreOrder: z.object({
-                    uuid: z.string(),
-                    preOrderNum: z.number(),
-                    clientName: z.string(),
-                }),
-                targetPreOrder: z.object({
-                    uuid: z.string(),
-                    preOrderNum: z.number(),
-                }),
-                warnings: z.array(ErrorMessageSchema),
-            }),
-        ),
-        failed: z.array(
-            z.object({
-                sourcePreOrder: z.object({
-                    uuid: z.string(),
-                    preOrderNum: z.number(),
-                    clientName: z.string(),
-                }),
-                error: z.array(ErrorMessageSchema),
-            }),
-        ),
-    }),
-});
+import { GroupCopyPreOrdersToCollectionRequestSchema } from '../../../schemas/pre-order/group-copy-pre-orders-to-collection-request.schema';
+import { GroupCopyPreOrdersToCollectionResponseSchema } from '../../../schemas/pre-order/group-copy-pre-orders-to-collection-response.schema';
 
 export namespace GroupCopyPreOrdersToCollectionContractCommand {
     export const RequestSchema = GroupCopyPreOrdersToCollectionRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = GroupCopyPreOrdersToCollectionResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/pre-order/group/group-delete-pre-order.command.ts

@@ -1,20 +1,10 @@
 import { z } from 'zod';
-
-const GroupDeletePreOrderRequestSchema = z.object({
-    uuids: z.array(z.string()),
-});
-
-const GroupDeletePreOrderResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-    }),
-});
+import { GroupDeletePreOrderRequestSchema } from '../../../schemas/pre-order/group-delete-pre-order-request.schema';
+import { GroupDeletePreOrderResponseSchema } from '../../../schemas/pre-order/group-delete-pre-order-response.schema';
 
 export namespace GroupDeletePreOrderContractCommand {
     export const RequestSchema = GroupDeletePreOrderRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = GroupDeletePreOrderResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

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

@@ -1,22 +1,10 @@
 import { z } from 'zod';
-import { UpdatePreOrderSchema } from '../../../schemas';
-
-const GroupUpdatePreOrderRequestSchema = z.object({
-    uuids: z.array(z.string()),
-    data: UpdatePreOrderSchema,
-});
-
-const GroupUpdatePreOrderResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-    }),
-});
+import { GroupUpdatePreOrderRequestSchema } from '../../../schemas/pre-order/group-update-pre-order-request.schema';
+import { GroupUpdatePreOrderResponseSchema } from '../../../schemas/pre-order/group-update-pre-order-response.schema';
 
 export namespace GroupUpdatePreOrderContractCommand {
     export const RequestSchema = GroupUpdatePreOrderRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = GroupUpdatePreOrderResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/pre-order/webshop/get-pre-order-list-webshop.command.ts

@@ -1,21 +1 @@
-import { z } from 'zod';
-import { PreOrderStatusEnum } from '../../../enum';
-import { PreOrderListSchema } from '../../../schemas';
-
-const GetPreOrderListWebshopRequestSchema = z.object({
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-    statuses: z.array(z.nativeEnum(PreOrderStatusEnum)).optional(),
-});
-
-const GetPreOrderListResponseSchema = z.object({
-    data: PreOrderListSchema,
-});
-
-export namespace GetPreOrderListWebshopContractCommand {
-    export const RequestSchema = GetPreOrderListWebshopRequestSchema;
-    export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = GetPreOrderListResponseSchema;
-    export type Response = z.infer<typeof ResponseSchema>;
-}
+export { GetPreOrderListWebshopContractCommand } from './get-pre-order-list-webshop.query';

package/commands/pre-order/webshop/get-pre-order-list-webshop.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { GetPreOrderListWebshopRequestSchema, GetPreOrderListWebshopResponseSchema } from '../../../schemas';
+
+export namespace GetPreOrderListWebshopContractCommand {
+    export const RequestSchema = GetPreOrderListWebshopRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = GetPreOrderListWebshopResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order/webshop/get-pre-order-webshop.query.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { GetPreOrderWebshopResponseSchema } from '../../../schemas';
+
+export namespace GetPreOrderWebshopContractQuery {
+    export const ResponseSchema = GetPreOrderWebshopResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order/webshop/index.ts

@@ -1,5 +1,6 @@
 export * from './update-pre-order-webshop.command';
 export * from './create-pre-order-webshop.command';
-export * from './get-pre-order-list-webshop.command';
+export * from './get-pre-order-list-webshop.query';
 export * from './delete-pre-order-webshop.command';
 export * from './checkout-pre-order-webshop.command';
+export * from './get-pre-order-webshop.query';

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

@@ -1,15 +1,10 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemSchema, CreatePreOrderCollectionItemSchema } from '../../schemas';
-
-const CreatePreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemSchema,
-});
+import { CreatePreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-collection-item/create-pre-order-collection-item-response.schema';
+import { CreatePreOrderCollectionItemSchema } from '../../schemas/pre-order-collection-item/create-pre-order-collection-item.schema';
 
 export namespace CreatePreOrderCollectionItemContractCommand {
     export const RequestSchema = CreatePreOrderCollectionItemSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = CreatePreOrderCollectionItemResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

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

@@ -1,16 +1,5 @@
 import { z } from 'zod';
-
-const DeleteGroupPreOrderCollectionItemRequestSchema = z.object({
-    preOrderCollectionItemUUIDs: z.array(z.string()),
-});
-
-const DeleteGroupPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-        missedItems: z.array(z.string()).optional(),
-    }),
-});
+import { DeleteGroupPreOrderCollectionItemRequestSchema, DeleteGroupPreOrderCollectionItemResponseSchema } from '../../schemas';
 
 export namespace DeleteGroupPreOrderCollectionItemContractCommand {
     export const RequestSchema = DeleteGroupPreOrderCollectionItemRequestSchema;

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

@@ -1,57 +1,10 @@
 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(),
-});
-
-const PositionUpdateSchema = 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(),
-    advancedPrice: z.string().nullable().optional(),
-    grower: z.string().nullable().optional(),
-    size: z.string().nullable().optional(),
-    size2: z.string().nullable().optional(),
-    size3: z.string().nullable().optional(),
-    color: z.string().nullable().optional(),
-    country: z.string().nullable().optional(),
-    vat: z.number().nullable().optional(),
-    description: z.string().nullable().optional(),
-    article: z.string().nullable().optional(),
-    salesUnit: z.string().nullable().optional(),
-    group: z.string().nullable().optional(),
-    multiplicityDescription: z.string().nullable().optional(),
-    option1: OptionUpdateSchema.optional(),
-    option2: OptionUpdateSchema.optional(),
-});
-
-const UpdateBatchRequestSchema = z.object({
-    updates: z.record(z.string(), PositionUpdateSchema),
-});
-
-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 { PreOrderCollectionItemUpdateBatchRequestSchema } from '../../schemas/pre-order-collection-item/pre-order-collection-item-update-batch-request.schema';
+import { PreOrderCollectionItemUpdateBatchResponseSchema } from '../../schemas/pre-order-collection-item/pre-order-collection-item-update-batch-response.schema';
 
 export namespace ExecutePreOrderCollectionItemUpdateContractCommand {
-    export const RequestSchema = UpdateBatchRequestSchema;
+    export const RequestSchema = PreOrderCollectionItemUpdateBatchRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
-    export const ResponseSchema = UpdateBatchResponseSchema;
+    export const ResponseSchema = PreOrderCollectionItemUpdateBatchResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/pre-order-collection-item/get-active-pre-order-collection-item-list.query.ts

@@ -1,21 +1,10 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemExtendedListSchema } from '../../schemas';
-
-const GetActivePreOrderCollectionItemListRequestSchema = z.object({
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-    searchQuery: z.string().optional(),
-});
-
-const GetActivePreOrderCollectionItemListResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemExtendedListSchema,
-});
+import { GetActivePreOrderCollectionItemListRequestSchema } from '../../schemas/pre-order-collection-item/get-active-pre-order-collection-item-list-request.schema';
+import { GetActivePreOrderCollectionItemListResponseSchema } from '../../schemas/pre-order-collection-item/get-active-pre-order-collection-item-list-response.schema';
 
 export namespace GetActivePreOrderCollectionItemListContract {
     export const RequestSchema = GetActivePreOrderCollectionItemListRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = GetActivePreOrderCollectionItemListResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/pre-order-collection-item/get-pre-order-collection-item-grouped-list-for-client.query.ts

@@ -1,25 +1,11 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemGroupedListSchema } from '../../schemas';
-
-const GetPreOrderCollectionItemGroupedListForClientRequestSchema = z.object({
-    sizes: z.array(z.string()).optional(),
-    colors: z.array(z.string()).optional(),
-    preOrderCollectionsUUID: z.array(z.string()).optional(),
-    categoriesUUID: z.array(z.string()).optional(),
-    growers: z.array(z.string()).optional(),
-    countries: z.array(z.string()).optional(),
-    searchQuery: z.string().optional(),
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-});
-
-const GetPreOrderCollectionItemGroupedListForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemGroupedListSchema,
-});
+import {
+    PreOrderCollectionItemCatalogFilterForClientRequestSchema,
+    GetPreOrderCollectionItemGroupedListForClientResponseSchema,
+} from '../../schemas';
 
 export namespace GetPreOrderCollectionItemGroupedListForClientContractQuery {
-    export const RequestSchema = GetPreOrderCollectionItemGroupedListForClientRequestSchema;
+    export const RequestSchema = PreOrderCollectionItemCatalogFilterForClientRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = GetPreOrderCollectionItemGroupedListForClientResponseSchema;

package/commands/pre-order-collection-item/get-pre-order-collection-item-list-for-client.query.ts

@@ -1,25 +1,11 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemExtendedWithPreOrderCollectionListSchema } from '../../schemas';
-
-const GetPreOrderCollectionItemListForClientRequestSchema = z.object({
-    sizes: z.array(z.string()).optional(),
-    colors: z.array(z.string()).optional(),
-    preOrderCollectionsUUID: z.array(z.string()).optional(),
-    categoriesUUID: z.array(z.string()).optional(),
-    growers: z.array(z.string()).optional(),
-    countries: z.array(z.string()).optional(),
-    searchQuery: z.string().optional(),
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-});
-
-const GetPreOrderCollectionItemListForClientResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemExtendedWithPreOrderCollectionListSchema,
-});
+import {
+    PreOrderCollectionItemCatalogFilterForClientRequestSchema,
+    GetPreOrderCollectionItemListForClientResponseSchema,
+} from '../../schemas';
 
 export namespace GetPreOrderCollectionItemListForClientContractQuery {
-    export const RequestSchema = GetPreOrderCollectionItemListForClientRequestSchema;
+    export const RequestSchema = PreOrderCollectionItemCatalogFilterForClientRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = GetPreOrderCollectionItemListForClientResponseSchema;

package/commands/pre-order-collection-item/get-pre-order-collection-item-list.query.ts

@@ -1,28 +1,10 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemExtendedListSchema } from '../../schemas';
-
-const GetPreOrderCollectionItemListRequestSchema = z.object({
-    page: z.coerce.number().optional().default(1),
-    count: z.coerce.number().optional().default(10),
-    sizes: z.array(z.string()).optional(),
-    colors: z.array(z.string()).optional(),
-    growers: z.array(z.string()).optional(),
-    countries: z.array(z.string()).optional(),
-    categoriesUUID: z.array(z.string()).optional(),
-    typesUUID: z.array(z.string()).optional(),
-    searchQuery: z.string().optional(),
-    hasPreOrder: z.coerce.boolean().optional(),
-});
-
-const GetPreOrderCollectionItemListResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemExtendedListSchema,
-});
+import { GetPreOrderCollectionItemListRequestSchema } from '../../schemas/pre-order-collection-item/get-pre-order-collection-item-list-request.schema';
+import { GetPreOrderCollectionItemListResponseSchema } from '../../schemas/pre-order-collection-item/get-pre-order-collection-item-list-response.schema';
 
 export namespace GetPreOrderCollectionItemListContract {
     export const RequestSchema = GetPreOrderCollectionItemListRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = GetPreOrderCollectionItemListResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/pre-order-collection-item/get-pre-order-collection-item.query.ts

@@ -1,10 +1,5 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemExtendedSchema } from '../../schemas';
-
-const GetPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemExtendedSchema,
-});
+import { GetPreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-collection-item/get-pre-order-collection-item-response.schema';
 
 export namespace GetPreOrderCollectionItemContractQuery {
     export const ResponseSchema = GetPreOrderCollectionItemResponseSchema;

package/commands/pre-order-collection-item/index.ts

@@ -1,28 +1,32 @@
+export * from './create-group-pre-order-collection-item.command';
 export * from './create-pre-order-collection-item.command';
-export * from './update-pre-order-collection-item.command';
-export * from './delete-pre-order-collection-item.command';
-export * from './get-pre-order-collection-item.query';
-export * from './get-pre-order-collection-item-list.query';
-export * from './get-pre-order-collection-item-list-filter-values.query';
 export * from './delete-group-pre-order-collection-item.command';
-export * from './update-group-pre-order-collection-item.command';
-export * from './create-group-pre-order-collection-item.command';
-export * from './get-pre-order-collection-item-extended-with-clients-pre-order-product-list.query';
+export * from './delete-pre-order-collection-item.command';
+export * from './export-pre-order-collection-item-with-clients-horizontal.query';
+export * from './export-pre-order-collection-item-with-clients-vertical.query';
 export * from './get-active-pre-order-collection-item-list.query';
+export * from './get-pre-order-collection-item-extended-with-clients-pre-order-product-list.query';
+export * from './get-pre-order-collection-item-grouped-list-for-client.query';
 export * from './get-pre-order-collection-item-list-filter-values-for-client.query';
+export * from './get-pre-order-collection-item-list-filter-values.query';
 export * from './get-pre-order-collection-item-list-for-client.query';
-export * from './get-pre-order-collection-item-grouped-list-for-client.query';
-export * from './export-pre-order-collection-item-with-clients-horizontal.query';
-export * from './export-pre-order-collection-item-with-clients-vertical.query';
+export * from './get-pre-order-collection-item-list.query';
+export * from './get-pre-order-collection-item.query';
+export * from './update-group-pre-order-collection-item.command';
 export * from './update-pre-order-collection-item-product-maching.command';
+export * from './update-pre-order-collection-item.command';
 // multiplicity options
-export * from './multiplicity-option/get-pre-order-collection-item-multiplicity-options.query';
-export * from './multiplicity-option/get-pre-order-collection-item-multiplicity-option-titles.query';
-export * from './multiplicity-option/create-pre-order-collection-item-multiplicity-option.command';
-export * from './multiplicity-option/update-pre-order-collection-item-multiplicity-option.command';
-export * from './multiplicity-option/delete-pre-order-collection-item-multiplicity-option.command';
-export * from './multiplicity-option/reorder-pre-order-collection-item-multiplicity-options.command';
 export * from './execute-pre-order-collection-item-update.command';
+export * from './import-pre-order-collection-item.command';
 export * from './move-pre-order-collection-items-analyze.command';
 export * from './move-pre-order-collection-items-execute.command';
-export * from './import-pre-order-collection-item.command';
+export * from './multiplicity-option/create-pre-order-collection-item-multiplicity-option.command';
+export * from './multiplicity-option/delete-pre-order-collection-item-multiplicity-option.command';
+export * from './multiplicity-option/get-pre-order-collection-item-multiplicity-option-titles.query';
+export * from './multiplicity-option/get-pre-order-collection-item-multiplicity-options.query';
+export * from './multiplicity-option/reorder-pre-order-collection-item-multiplicity-options.command';
+export * from './multiplicity-option/update-pre-order-collection-item-multiplicity-option.command';
+export * from './supplier-add-pre-order-collection-items-analyze.command';
+export * from './supplier-add-pre-order-collection-items-execute.command';
+export * from './supplier-sync-pre-order-collection-items-analyze.command';
+export * from './supplier-sync-pre-order-collection-items-execute.command';

package/commands/pre-order-collection-item/supplier-add-pre-order-collection-items-analyze.command.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { SupplierAddAnalyzeRequestSchema } from '../../schemas/pre-order-collection-item/supplier-add-analyze-request.schema';
+import { SupplierAddAnalyzeResponseSchema } from '../../schemas/pre-order-collection-item/supplier-add-analyze-response.schema';
+
+/**
+ * Предпросмотр добавления предложений поставщика в коллекцию предзаказа: только чтение, те же правила, что у execute.
+ */
+export namespace SupplierAddPreOrderCollectionItemsAnalyzeContractCommand {
+    export const RequestSchema = SupplierAddAnalyzeRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = SupplierAddAnalyzeResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order-collection-item/supplier-add-pre-order-collection-items-execute.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SupplierAddExecuteRequestSchema } from '../../schemas/pre-order-collection-item/supplier-add-execute-request.schema';
+import { SupplierAddExecuteResponseSchema } from '../../schemas/pre-order-collection-item/supplier-add-execute-response.schema';
+
+/**
+ * Добавление предложений поставщика в коллекцию предзаказа: сервер заново находит предложения по ключам компании,
+ * берёт живую карточку компании или создаёт её из шаблона и заводит позиции с полями поставщика одной транзакцией.
+ */
+export namespace SupplierAddPreOrderCollectionItemsExecuteContractCommand {
+    export const RequestSchema = SupplierAddExecuteRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = SupplierAddExecuteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order-collection-item/supplier-sync-pre-order-collection-items-analyze.command.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { SupplierSyncAnalyzeRequestSchema } from '../../schemas/pre-order-collection-item/supplier-sync-analyze-request.schema';
+import { SupplierSyncAnalyzeResponseSchema } from '../../schemas/pre-order-collection-item/supplier-sync-analyze-response.schema';
+
+/**
+ * Предпросмотр синхронизации позиций коллекции предзаказа с предложениями поставщика из последнего синка: только
+ * чтение, те же правила сопоставления, что у execute.
+ */
+export namespace SupplierSyncPreOrderCollectionItemsAnalyzeContractCommand {
+    export const RequestSchema = SupplierSyncAnalyzeRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = SupplierSyncAnalyzeResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order-collection-item/supplier-sync-pre-order-collection-items-execute.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { SupplierSyncExecuteRequestSchema } from '../../schemas/pre-order-collection-item/supplier-sync-execute-request.schema';
+import { SupplierSyncExecuteResponseSchema } from '../../schemas/pre-order-collection-item/supplier-sync-execute-response.schema';
+
+/**
+ * Синхронизация выбранных позиций коллекции предзаказа с поставщиком: меняются только поля поставщика (закупка, дата
+ * вылета, код при REMAPPED, метка «снято»), кратность — только с applyMultiplicity. Продажная цена, открытость и остаток
+ * не трогаются. Одна транзакция.
+ */
+export namespace SupplierSyncPreOrderCollectionItemsExecuteContractCommand {
+    export const RequestSchema = SupplierSyncExecuteRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = SupplierSyncExecuteResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

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

@@ -1,15 +1,10 @@
 import { z } from 'zod';
-import { PreOrderCollectionItemSchema, UpdatePreOrderCollectionItemSchema } from '../../schemas';
-
-const UpdatePreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderCollectionItemSchema,
-});
+import { UpdatePreOrderCollectionItemRequestSchema } from '../../schemas/pre-order-collection-item/update-pre-order-collection-item-request.schema';
+import { UpdatePreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-collection-item/update-pre-order-collection-item-response.schema';
 
 export namespace UpdatePreOrderCollectionItemContractCommand {
-    export const RequestSchema = UpdatePreOrderCollectionItemSchema;
+    export const RequestSchema = UpdatePreOrderCollectionItemRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
-
     export const ResponseSchema = UpdatePreOrderCollectionItemResponseSchema;
     export type Response = z.infer<typeof ResponseSchema>;
 }

package/commands/pre-order-product/create-pre-order-product-webshop.command.ts

@@ -1,13 +1,8 @@
 import { z } from 'zod';
-import { CreatePreOrderProductWebshopSchema, PreOrderProductSchema } from '../../schemas';
-
-const CreatePreOrderProductWebshopResponseSchema = z.object({
-    message: z.string().optional(),
-    data: PreOrderProductSchema,
-});
+import { CreatePreOrderProductWebshopRequestSchema, CreatePreOrderProductWebshopResponseSchema } from '../../schemas';
 
 export namespace CreatePreOrderProductWebshopContractCommand {
-    export const RequestSchema = CreatePreOrderProductWebshopSchema;
+    export const RequestSchema = CreatePreOrderProductWebshopRequestSchema;
     export type Request = z.infer<typeof RequestSchema>;
 
     export const ResponseSchema = CreatePreOrderProductWebshopResponseSchema;

package/commands/pre-order-product/delete-many-pre-order-product-by-pre-order-collection-item.command.ts

@@ -1,11 +1,5 @@
 import { z } from 'zod';
-
-const DeleteManyPreOrderProductByPreOrderCollectionItemResponseSchema = z.object({
-    message: z.string().optional(),
-    data: z.object({
-        success: z.boolean(),
-    }),
-});
+import { DeleteManyPreOrderProductByPreOrderCollectionItemResponseSchema } from '../../schemas/pre-order-product/delete-many-pre-order-product-by-pre-order-collection-item-response.schema';
 
 export namespace DeleteManyPreOrderProductByPreOrderCollectionItemContractCommand {
     export const ResponseSchema = DeleteManyPreOrderProductByPreOrderCollectionItemResponseSchema;

package/commands/pre-order-product/get-pre-order-product-extended-list-webshop.query.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { PaginationRequestSchema, GetPreOrderProductExtendedListWebshopResponseSchema } from '../../schemas';
+
+export namespace GetPreOrderProductExtendedListWebshopContractQuery {
+    export const RequestSchema = PaginationRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = GetPreOrderProductExtendedListWebshopResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/pre-order-product/index.ts

@@ -11,6 +11,7 @@ export * from './delete-pre-order-product-webshop.command';
 export * from './update-pre-order-product-webshop.command';
 export * from './get-pre-order-product-list.query';
 export * from './get-pre-order-product-extended-list.query';
+export * from './get-pre-order-product-extended-list-webshop.query';
 export * from './get-active-stepper-positions.query';
 export * from './create-manually-pre-order-product-for-standing-order.command';
 export * from './get-pre-order-products-by-pre-order-list.command';