@floristcloud/api-lib 1.2.161 → 1.2.163

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-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/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/user/getUser.command.ts

@@ -1,5 +1,5 @@
-import { UserSchema } from '../../schemas';
 import { z } from 'zod';
+import { UserSchema } from '../../schemas';
 
 const GetUserRequestSchema = z.object({
     data: z.object({

package/constant/error-i18n-key.ts

@@ -74,6 +74,18 @@ export const ErrorI18nKey = {
     soProductNotCreated: 'preOrderFromStandingOrder.productNotCreated',
     soCriticalError: 'preOrderFromStandingOrder.criticalError',
     soNoPreOrdersCreated: 'preOrderFromStandingOrder.noPreOrdersCreated',
+    soItemSkippedInsufficientBalance: 'preOrderFromStandingOrder.itemSkippedInsufficientBalance',
+    soPlanItemPartiallyAllocated: 'preOrderFromStandingOrder.planItemPartiallyAllocated',
+    soLineAlreadyConverted: 'preOrderFromStandingOrder.lineAlreadyConverted',
+
+    // Standing-order → pre-order conversion plan validation
+    soPlanMismatch: 'standingOrderPlan.mismatch',
+    soPlanDuplicateStandingOrder: 'standingOrderPlan.duplicateStandingOrder',
+    soPlanDuplicateLine: 'standingOrderPlan.duplicateLine',
+    soPlanDuplicateItem: 'standingOrderPlan.duplicateItem',
+    soPlanLineNotInStandingOrder: 'standingOrderPlan.lineNotInStandingOrder',
+    soPlanItemNotAvailable: 'standingOrderPlan.itemNotAvailable',
+    soPlanQuantityExceedsLine: 'standingOrderPlan.quantityExceedsLine',
 
     // Pre-order → standing-order conversion warnings
     preOrderToSoSourceEmpty: 'preOrderToStandingOrder.sourceEmpty',

package/constant/error.ts

@@ -356,6 +356,11 @@ export const ERRORS = {
         message: 'Cannot delete category template that has product image templates',
         httpCode: 409,
     },
+    CATEGORY_TEMPLATE_LOCK_TIMEOUT: {
+        code: 'CT008',
+        message: 'Categories of the company are being created from templates by another operation, retry later',
+        httpCode: 409,
+    },
 
     // ProductImageTemplate
     PRODUCT_IMAGE_TEMPLATE_NOT_CREATED: { code: 'PIT001', message: 'Failed to create product image template', httpCode: 500 },
@@ -366,6 +371,46 @@ export const ERRORS = {
     PRODUCT_IMAGE_TEMPLATE_SYNC_FAILED: { code: 'PIT006', message: 'Error when sync product image template', httpCode: 500 },
     PRODUCT_IMAGE_GROUP_NOT_DELETED: { code: 'PIT007', message: 'Product image group not deleted', httpCode: 500 },
     PRODUCT_IMAGE_GROUP_NOT_UPDATED: { code: 'PIT008', message: 'Product image group not updated', httpCode: 500 },
+    PRODUCT_IMAGE_TEMPLATE_IMPORT_FAILED: {
+        code: 'PIT009',
+        message: 'Failed to import product image templates into the company catalog',
+        httpCode: 500,
+    },
+    PRODUCT_IMAGE_TEMPLATE_IMPORT_LOCK_TIMEOUT: {
+        code: 'PIT010',
+        message: 'Product image templates are being imported into the company catalog by another operation, retry later',
+        httpCode: 409,
+    },
+    PRODUCT_IMAGE_TEMPLATE_SYNC_IN_PROGRESS: {
+        code: 'PIT011',
+        message: 'Product image templates sync is already running for the company, retry later',
+        httpCode: 409,
+    },
+    PRODUCT_IMAGE_TEMPLATE_SOURCE_DELETE_FORBIDDEN: {
+        code: 'PIT012',
+        message: 'A product image template received from a supplier catalog cannot be deleted: the next delivery would bring it back',
+        httpCode: 409,
+    },
+    PRODUCT_IMAGE_TEMPLATE_SOURCE_IDENTITY_READONLY: {
+        code: 'PIT013',
+        message: 'Name and grower of a product image template received from a supplier catalog cannot be changed',
+        httpCode: 409,
+    },
+    PRODUCT_IMAGE_TEMPLATE_ACCESS_NOT_GRANTED: {
+        code: 'PIT014',
+        message: 'Failed to grant the company access to supplier product image templates',
+        httpCode: 500,
+    },
+    PRODUCT_IMAGE_TEMPLATE_ACCESS_FETCH_FAILED: {
+        code: 'PIT015',
+        message: 'Failed to read supplier product image templates pending import to the company',
+        httpCode: 500,
+    },
+    PRODUCT_IMAGE_TEMPLATE_ACCESS_NOT_MARKED: {
+        code: 'PIT016',
+        message: 'Failed to mark supplier product image templates as imported to the company',
+        httpCode: 500,
+    },
     //WRITE OFF
     WRITE_OFF_NOT_CREATED: { code: 'W001', message: 'Failed to create write off', httpCode: 500 },
     WRITE_OFF_FETCH_FAILED: { code: 'W002', message: 'Error when retrieving a write off', httpCode: 500 },
@@ -733,6 +778,11 @@ export const ERRORS = {
     CATEGORY_USE_IN_PRODUCT: { code: 'CA016', message: 'Category use in product', httpCode: 500 },
     CATEGORY_USE_IN_PRE_ORDER_COLLECTION_ITEM: { code: 'CA017', message: 'Category use in pre order collection item', httpCode: 500 },
     CATEGORY_USE_IN_PRODUCT_IMAGE: { code: 'CA018', message: 'Category use in product image', httpCode: 500 },
+    CATEGORY_DELETE_LOCK_TIMEOUT: {
+        code: 'CA020',
+        message: 'Product images of the company are being updated by another operation, retry deleting the category later',
+        httpCode: 409,
+    },
 
     // CATEGORY ALIAS
     ALIAS_NOT_CREATED: { code: 'AL009', message: 'Failed to create category-category-category-alias', httpCode: 500 },
@@ -980,6 +1030,47 @@ export const ERRORS = {
         message: 'No pre-orders were created for this standing order: no matching items found in the selected collections',
         httpCode: 400,
     },
+    PRE_ORDER_SO_ITEM_SKIPPED_INSUFFICIENT_BALANCE: {
+        code: 'PO055',
+        message: 'Standing-order item was skipped: the collection item balance is no longer sufficient',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_ITEM_PARTIALLY_ALLOCATED: {
+        code: 'PO056',
+        message: 'Only part of the standing-order item quantity was added to the pre-order',
+        httpCode: 400,
+    },
+    // PRE ORDER — standing-order → pre-order conversion plan validation and repeat guard
+    PRE_ORDER_SO_PLAN_MISMATCH: {
+        code: 'PO049',
+        message: 'Conversion plan must cover exactly the requested standing orders',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_DUPLICATE_ENTRY: {
+        code: 'PO050',
+        message: 'Conversion plan contains duplicate entries',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_LINE_NOT_IN_STANDING_ORDER: {
+        code: 'PO051',
+        message: 'Planned line does not belong to its standing order',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_ITEM_NOT_AVAILABLE: {
+        code: 'PO052',
+        message: 'Planned collection item does not belong to the selected collections',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_PLAN_QUANTITY_EXCEEDS_LINE: {
+        code: 'PO053',
+        message: 'Planned quantity exceeds the standing-order line quantity',
+        httpCode: 400,
+    },
+    PRE_ORDER_SO_LINE_ALREADY_CONVERTED: {
+        code: 'PO054',
+        message: 'Standing-order line has already been converted into this collection',
+        httpCode: 409,
+    },
     // PRE ORDER — pre-order → standing-order conversion
     PRE_ORDER_TO_STANDING_ORDER_FAILED: {
         code: 'PO044',
@@ -1001,6 +1092,11 @@ export const ERRORS = {
         message: 'Failed to create standing-order position from pre-order position',
         httpCode: 400,
     },
+    PRE_ORDER_CONVERSION_ANALYSIS_STALE: {
+        code: 'PO048',
+        message: 'The pre-order changed after the conversion analysis, analyze it again',
+        httpCode: 409,
+    },
     // PRE ORDER — copy pre-order per-item warnings
     PRE_ORDER_COPY_ITEM_NO_MATCHES: {
         code: 'PO032',
@@ -1227,6 +1323,41 @@ export const ERRORS = {
         message: 'Batch size too large',
         httpCode: 400,
     },
+    PRE_ORDER_COLLECTION_ITEM_SUPPLIER_NOT_UPDATED: {
+        code: 'POCI036',
+        message: 'Failed to update supplier fields of pre order collection items',
+        httpCode: 500,
+    },
+    PRE_ORDER_COLLECTION_ITEM_TRACKED_SUPPLIER_OFFER_CODES_FETCH_FAILED: {
+        code: 'POCI037',
+        message: 'Failed to read supplier offer codes tracked by pre order collections',
+        httpCode: 500,
+    },
+    PRE_ORDER_COLLECTION_ITEM_SUPPLIER_INVALID: {
+        code: 'POCI038',
+        message: 'Invalid supplier fields: currency must be 3 letters, invoice price non-negative with at most 4 decimals',
+        httpCode: 400,
+    },
+    PRE_ORDER_LOCK_CONFLICT: {
+        code: 'POCI039',
+        message: 'The pre-order or its collection item is being changed by another operation, retry the request',
+        httpCode: 409,
+    },
+    PRE_ORDER_COLLECTION_ITEM_MULTIPLICITY_OPTION_NOT_AVAILABLE: {
+        code: 'POCI033',
+        message: 'The multiplicity option was removed or belongs to another collection item',
+        httpCode: 400,
+    },
+    PRE_ORDER_COLLECTION_ITEM_SUPPLIER_ADD_FAILED: {
+        code: 'POCI034',
+        message: 'Failed to add supplier offers to the pre order collection',
+        httpCode: 500,
+    },
+    PRE_ORDER_COLLECTION_ITEM_SUPPLIER_SYNC_FAILED: {
+        code: 'POCI035',
+        message: 'Failed to sync pre order collection items with the supplier',
+        httpCode: 500,
+    },
     PRE_ORDER_COLLECTION_ITEM_MOVE_STANDING_ORDER_CATALOG: {
         code: 'POCI029',
         message: 'Items cannot be moved to or from the standing order catalog',
@@ -1564,6 +1695,67 @@ export const ERRORS = {
     ONE_C_INTEGRATION_DISABLED: { code: 'OC004', message: '1C integration is disabled for this company', httpCode: 409 },
     ONE_C_SESSION_INVALID: { code: 'OC005', message: '1C session is missing or expired', httpCode: 401 },
 
+    // COMPANY INTEGRATION (общая запись интеграции компании)
+    COMPANY_INTEGRATION_FETCH_FAILED: { code: 'CINT001', message: 'Failed to read company integration', httpCode: 500 },
+    COMPANY_INTEGRATION_NOT_SAVED: { code: 'CINT002', message: 'Failed to save company integration', httpCode: 500 },
+    COMPANY_INTEGRATION_NOT_DELETED: { code: 'CINT003', message: 'Failed to delete company integration', httpCode: 500 },
+    COMPANY_INTEGRATION_NOT_FOUND: { code: 'CINT004', message: 'Company integration not found', httpCode: 404 },
+    COMPANY_INTEGRATION_UNIT_NOT_FOUND: {
+        code: 'CINT005',
+        message: 'The unit is not among the saved units of the company integration',
+        httpCode: 400,
+    },
+
+    // OZEXPORT INTEGRATION (FC-513)
+    OZEXPORT_AUTH_FAILED: { code: 'OZ001', message: 'ozexport rejected the username or password', httpCode: 400 },
+    OZEXPORT_PARSER_UNAVAILABLE: {
+        code: 'OZ002',
+        message: 'Failed to check ozexport credentials: the catalog service is unavailable, retry later',
+        httpCode: 503,
+    },
+    OZEXPORT_NOT_CONNECTED: { code: 'OZ003', message: 'ozexport integration is not connected for this company', httpCode: 404 },
+    OZEXPORT_CONNECT_FAILED: { code: 'OZ004', message: 'Failed to connect ozexport integration', httpCode: 500 },
+    OZEXPORT_UPDATE_FAILED: { code: 'OZ005', message: 'Failed to update ozexport integration', httpCode: 500 },
+    OZEXPORT_DISCONNECT_FAILED: { code: 'OZ006', message: 'Failed to disconnect ozexport integration', httpCode: 500 },
+    OZEXPORT_UNIT_NOT_FOUND: {
+        code: 'OZ007',
+        message: 'The unit is not among the units of the connected ozexport account',
+        httpCode: 400,
+    },
+    OZEXPORT_STATUS_FETCH_FAILED: { code: 'OZ008', message: 'Failed to read ozexport integration status', httpCode: 500 },
+    OZEXPORT_CONNECT_IN_PROGRESS: {
+        code: 'OZ009',
+        message: 'ozexport credentials of the company are being changed by another request, retry later',
+        httpCode: 409,
+    },
+    OZEXPORT_UNIT_NOT_SELECTED: {
+        code: 'OZ010',
+        message: 'Select the ozexport unit before enabling the integration',
+        httpCode: 409,
+    },
+    OZEXPORT_CREDENTIALS_UNREADABLE: {
+        code: 'OZ011',
+        message: 'Stored ozexport credentials cannot be read, reconnect the integration',
+        httpCode: 500,
+    },
+    OZEXPORT_DISABLED: { code: 'OZ012', message: 'ozexport integration is disabled for this company', httpCode: 409 },
+    OZEXPORT_CATALOG_FETCH_FAILED: { code: 'OZ013', message: 'Failed to read the ozexport catalog', httpCode: 500 },
+
+    // SUPPLIER OFFERS / SUPPLIER SYNC JOBS (FC-513)
+    SUPPLIER_OFFER_NOT_SAVED: { code: 'SOF001', message: 'Failed to save supplier offers', httpCode: 500 },
+    SUPPLIER_OFFER_NOT_DELETED: { code: 'SOF002', message: 'Failed to delete supplier offers', httpCode: 500 },
+    SUPPLIER_OFFER_FETCH_FAILED: { code: 'SOF003', message: 'Failed to read supplier offers', httpCode: 500 },
+    // Задание не активно (отменено, завершено, неизвестно) или попытка устарела: парсер прерывает задание.
+    SUPPLIER_JOB_NOT_ACTIVE: {
+        code: 'SSJ001',
+        message: 'The supplier sync job is not active or the attempt is stale',
+        httpCode: 409,
+    },
+    SUPPLIER_JOB_BATCH_FAILED: { code: 'SSJ002', message: 'Failed to process the supplier sync job batch', httpCode: 500 },
+    SUPPLIER_JOB_COMPLETE_FAILED: { code: 'SSJ003', message: 'Failed to complete the supplier sync job', httpCode: 500 },
+    SUPPLIER_JOB_SCHEDULE_FAILED: { code: 'SSJ004', message: 'Failed to schedule supplier sync jobs', httpCode: 500 },
+    SUPPLIER_JOB_DISPATCH_FAILED: { code: 'SSJ005', message: 'Failed to dispatch supplier sync jobs', httpCode: 500 },
+
     // CONSIGNMENT TRANSFER (FC-227)
     CONSIGNMENT_TRANSFER_NOT_CREATED: { code: 'CTR001', message: 'Failed to create consignment transfer request', httpCode: 500 },
     CONSIGNMENT_TRANSFER_NOT_FOUND: { code: 'CTR002', message: 'Consignment transfer request not found', httpCode: 404 },
@@ -1716,6 +1908,11 @@ export const ERRORS = {
         message: 'Another product image merge is already in progress for this company',
         httpCode: 409,
     },
+    PRODUCT_IMAGE_LOCK_CONFLICT: {
+        code: 'PI018',
+        message: 'Product image links changed concurrently, retry the operation',
+        httpCode: 409,
+    },
     GROWER_SUGGESTIONS_FETCH_FAILED: {
         code: 'ANORM004',
         message: 'Error when retrieving grower suggestions',

package/enum/action-log-type.enum.ts

@@ -78,5 +78,6 @@ export enum ActionLogTypeEnum {
     UPDATE_CLIENT_MARKING = 'UPDATE_CLIENT_MARKING',
     UPDATE_CLIENT_PROFILE = 'UPDATE_CLIENT_PROFILE',
     COPY_PREORDER_COLLECTION = 'COPY_PREORDER_COLLECTION',
+    SUPPLIER_SYNC_COLLECTION_ITEMS = 'SUPPLIER_SYNC_COLLECTION_ITEMS',
     MERGE_PRODUCT_IMAGES = 'MERGE_PRODUCT_IMAGES',
 }

package/enum/deleted-by-company-policy.enum.ts

@@ -0,0 +1,5 @@
+// Автоматический импорт уважает удаления компании; явное добавление разрешает повторное создание.
+export enum DeletedByCompanyPolicyEnum {
+    SKIP = 'SKIP',
+    RECREATE = 'RECREATE',
+}